Api roll 2: 2014-09-29

generated/googleapis/lib/webmasters/v3.dart

Index: generated/googleapis/lib/webmasters/v3.dart
diff --git a/generated/googleapis/lib/webmasters/v3.dart b/generated/googleapis/lib/webmasters/v3.dart
new file mode 100644
index 0000000000000000000000000000000000000000..6c887142796e7785a3b90d8231af3fe279b4a17a
--- /dev/null
+++ b/generated/googleapis/lib/webmasters/v3.dart
@@ -0,0 +1,1160 @@
+library googleapis.webmasters.v3;
+
+import "dart:core" as core;
+import "dart:collection" as collection;
+import "dart:async" as async;
+import "dart:convert" as convert;
+
+import "package:crypto/crypto.dart" as crypto;
+import 'package:http/http.dart' as http;
+import '../src/common_internal.dart' as common_internal;
+import '../common/common.dart' as common;
+
+export '../common/common.dart' show ApiRequestError;
+export '../common/common.dart' show DetailedApiRequestError;
+
+/** Lets you view Google Webmaster Tools data for your verified sites. */
+class WebmastersApi {
+  /** View and modify Webmaster Tools data for your verified sites */
+  static const WebmastersScope = "https://www.googleapis.com/auth/webmasters";
+
+  /** View Webmaster Tools data for your verified sites */
+  static const WebmastersReadonlyScope = "https://www.googleapis.com/auth/webmasters.readonly";
+
+
+  final common_internal.ApiRequester _requester;
+
+  SitemapsResourceApi get sitemaps => new SitemapsResourceApi(_requester);
+  SitesResourceApi get sites => new SitesResourceApi(_requester);
+  UrlcrawlerrorscountsResourceApi get urlcrawlerrorscounts => new UrlcrawlerrorscountsResourceApi(_requester);
+  UrlcrawlerrorssamplesResourceApi get urlcrawlerrorssamples => new UrlcrawlerrorssamplesResourceApi(_requester);
+
+  WebmastersApi(http.Client client) : 
+      _requester = new common_internal.ApiRequester(client, "https://www.googleapis.com/", "webmasters/v3/");
+}
+
+
+/** Not documented yet. */
+class SitemapsResourceApi {
+  final common_internal.ApiRequester _requester;
+
+  SitemapsResourceApi(common_internal.ApiRequester client) : 
+      _requester = client;
+
+  /**
+   * Deletes a sitemap from this site.
+   *
+   * Request parameters:
+   *
+   * [siteUrl] - The site's URL, including protocol, for example
+   * 'http://www.example.com/'
+   *
+   * [feedpath] - The URL of the actual sitemap (for example
+   * http://www.example.com/sitemap.xml).
+   *
+   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method  will complete with the same error.
+   */
+  async.Future delete(core.String siteUrl, core.String feedpath) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (siteUrl == null) {
+      throw new core.ArgumentError("Parameter siteUrl is required.");
+    }
+    if (feedpath == null) {
+      throw new core.ArgumentError("Parameter feedpath is required.");
+    }
+
+    _downloadOptions = null;
+
+    _url = 'sites/' + common_internal.Escaper.ecapeVariable('$siteUrl') + '/sitemaps/' + common_internal.Escaper.ecapeVariable('$feedpath');
+
+    var _response = _requester.request(_url,
+                                       "DELETE",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => null);
+  }
+
+  /**
+   * Retrieves information about a specific sitemap.
+   *
+   * Request parameters:
+   *
+   * [siteUrl] - The site's URL, including protocol, for example
+   * 'http://www.example.com/'
+   *
+   * [feedpath] - The URL of the actual sitemap (for example
+   * http://www.example.com/sitemap.xml).
+   *
+   * Completes with a [WmxSitemap].
+   *
+   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method  will complete with the same error.
+   */
+  async.Future<WmxSitemap> get(core.String siteUrl, core.String feedpath) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (siteUrl == null) {
+      throw new core.ArgumentError("Parameter siteUrl is required.");
+    }
+    if (feedpath == null) {
+      throw new core.ArgumentError("Parameter feedpath is required.");
+    }
+
+
+    _url = 'sites/' + common_internal.Escaper.ecapeVariable('$siteUrl') + '/sitemaps/' + common_internal.Escaper.ecapeVariable('$feedpath');
+
+    var _response = _requester.request(_url,
+                                       "GET",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new WmxSitemap.fromJson(data));
+  }
+
+  /**
+   * Lists sitemaps uploaded to the site.
+   *
+   * Request parameters:
+   *
+   * [siteUrl] - The site's URL, including protocol, for example
+   * 'http://www.example.com/'
+   *
+   * [sitemapIndex] - A URL of a site's sitemap index.
+   *
+   * Completes with a [SitemapsListResponse].
+   *
+   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method  will complete with the same error.
+   */
+  async.Future<SitemapsListResponse> list(core.String siteUrl, {core.String sitemapIndex}) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (siteUrl == null) {
+      throw new core.ArgumentError("Parameter siteUrl is required.");
+    }
+    if (sitemapIndex != null) {
+      _queryParams["sitemapIndex"] = [sitemapIndex];
+    }
+
+
+    _url = 'sites/' + common_internal.Escaper.ecapeVariable('$siteUrl') + '/sitemaps';
+
+    var _response = _requester.request(_url,
+                                       "GET",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new SitemapsListResponse.fromJson(data));
+  }
+
+  /**
+   * Submits a sitemap for a site.
+   *
+   * Request parameters:
+   *
+   * [siteUrl] - The site's URL, including protocol, for example
+   * 'http://www.example.com/'
+   *
+   * [feedpath] - The URL of the sitemap to add.
+   *
+   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method  will complete with the same error.
+   */
+  async.Future submit(core.String siteUrl, core.String feedpath) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (siteUrl == null) {
+      throw new core.ArgumentError("Parameter siteUrl is required.");
+    }
+    if (feedpath == null) {
+      throw new core.ArgumentError("Parameter feedpath is required.");
+    }
+
+    _downloadOptions = null;
+
+    _url = 'sites/' + common_internal.Escaper.ecapeVariable('$siteUrl') + '/sitemaps/' + common_internal.Escaper.ecapeVariable('$feedpath');
+
+    var _response = _requester.request(_url,
+                                       "PUT",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => null);
+  }
+
+}
+
+
+/** Not documented yet. */
+class SitesResourceApi {
+  final common_internal.ApiRequester _requester;
+
+  SitesResourceApi(common_internal.ApiRequester client) : 
+      _requester = client;
+
+  /**
+   * Adds a site to the set of the user's sites in Webmaster Tools.
+   *
+   * Request parameters:
+   *
+   * [siteUrl] - The URL of the site to add.
+   *
+   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method  will complete with the same error.
+   */
+  async.Future add(core.String siteUrl) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (siteUrl == null) {
+      throw new core.ArgumentError("Parameter siteUrl is required.");
+    }
+
+    _downloadOptions = null;
+
+    _url = 'sites/' + common_internal.Escaper.ecapeVariable('$siteUrl');
+
+    var _response = _requester.request(_url,
+                                       "PUT",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => null);
+  }
+
+  /**
+   * Removes a site from the set of the user's Webmaster Tools sites.
+   *
+   * Request parameters:
+   *
+   * [siteUrl] - The site's URL, including protocol, for example
+   * 'http://www.example.com/'
+   *
+   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method  will complete with the same error.
+   */
+  async.Future delete(core.String siteUrl) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (siteUrl == null) {
+      throw new core.ArgumentError("Parameter siteUrl is required.");
+    }
+
+    _downloadOptions = null;
+
+    _url = 'sites/' + common_internal.Escaper.ecapeVariable('$siteUrl');
+
+    var _response = _requester.request(_url,
+                                       "DELETE",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => null);
+  }
+
+  /**
+   * Retrieves information about specific site.
+   *
+   * Request parameters:
+   *
+   * [siteUrl] - The site's URL, including protocol, for example
+   * 'http://www.example.com/'
+   *
+   * Completes with a [WmxSite].
+   *
+   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method  will complete with the same error.
+   */
+  async.Future<WmxSite> get(core.String siteUrl) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (siteUrl == null) {
+      throw new core.ArgumentError("Parameter siteUrl is required.");
+    }
+
+
+    _url = 'sites/' + common_internal.Escaper.ecapeVariable('$siteUrl');
+
+    var _response = _requester.request(_url,
+                                       "GET",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new WmxSite.fromJson(data));
+  }
+
+  /**
+   * Lists your Webmaster Tools sites.
+   *
+   * Request parameters:
+   *
+   * Completes with a [SitesListResponse].
+   *
+   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method  will complete with the same error.
+   */
+  async.Future<SitesListResponse> list() {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _body = null;
+
+
+
+    _url = 'sites';
+
+    var _response = _requester.request(_url,
+                                       "GET",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new SitesListResponse.fromJson(data));
+  }
+
+}
+
+
+/** Not documented yet. */
+class UrlcrawlerrorscountsResourceApi {
+  final common_internal.ApiRequester _requester;
+
+  UrlcrawlerrorscountsResourceApi(common_internal.ApiRequester client) : 
+      _requester = client;
+
+  /**
+   * Retrieves a time series of the number of URL crawl errors per error
+   * category and platform.
+   *
+   * Request parameters:
+   *
+   * [siteUrl] - The site's URL, including protocol, for example
+   * 'http://www.example.com/'
+   *
+   * [category] - The crawl error category, for example 'serverError'. If not
+   * specified, we return results for all categories.
+   * Possible string values are:
+   * - "authPermissions"
+   * - "manyToOneRedirect"
+   * - "notFollowed"
+   * - "notFound"
+   * - "other"
+   * - "roboted"
+   * - "serverError"
+   * - "soft404"
+   *
+   * [latestCountsOnly] - If true, returns only the latest crawl error counts.
+   *
+   * [platform] - The user agent type (platform) that made the request, for
+   * example 'web'. If not specified, we return results for all platforms.
+   * Possible string values are:
+   * - "mobile"
+   * - "smartphoneOnly"
+   * - "web"
+   *
+   * Completes with a [UrlCrawlErrorsCountsQueryResponse].
+   *
+   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method  will complete with the same error.
+   */
+  async.Future<UrlCrawlErrorsCountsQueryResponse> query(core.String siteUrl, {core.String category, core.bool latestCountsOnly, core.String platform}) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (siteUrl == null) {
+      throw new core.ArgumentError("Parameter siteUrl is required.");
+    }
+    if (category != null) {
+      _queryParams["category"] = [category];
+    }
+    if (latestCountsOnly != null) {
+      _queryParams["latestCountsOnly"] = ["${latestCountsOnly}"];
+    }
+    if (platform != null) {
+      _queryParams["platform"] = [platform];
+    }
+
+
+    _url = 'sites/' + common_internal.Escaper.ecapeVariable('$siteUrl') + '/urlCrawlErrorsCounts/query';
+
+    var _response = _requester.request(_url,
+                                       "GET",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new UrlCrawlErrorsCountsQueryResponse.fromJson(data));
+  }
+
+}
+
+
+/** Not documented yet. */
+class UrlcrawlerrorssamplesResourceApi {
+  final common_internal.ApiRequester _requester;
+
+  UrlcrawlerrorssamplesResourceApi(common_internal.ApiRequester client) : 
+      _requester = client;
+
+  /**
+   * Retrieves details about crawl errors for a site's sample URL.
+   *
+   * Request parameters:
+   *
+   * [siteUrl] - The site's URL, including protocol, for example
+   * 'http://www.example.com/'
+   *
+   * [url] - The relative path (without the site) of the sample URL; must be one
+   * of the URLs returned by list
+   *
+   * [category] - The crawl error category, for example 'authPermissions'
+   * Possible string values are:
+   * - "authPermissions"
+   * - "manyToOneRedirect"
+   * - "notFollowed"
+   * - "notFound"
+   * - "other"
+   * - "roboted"
+   * - "serverError"
+   * - "soft404"
+   *
+   * [platform] - The user agent type (platform) that made the request, for
+   * example 'web'
+   * Possible string values are:
+   * - "mobile"
+   * - "smartphoneOnly"
+   * - "web"
+   *
+   * Completes with a [UrlCrawlErrorsSample].
+   *
+   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method  will complete with the same error.
+   */
+  async.Future<UrlCrawlErrorsSample> get(core.String siteUrl, core.String url, core.String category, core.String platform) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (siteUrl == null) {
+      throw new core.ArgumentError("Parameter siteUrl is required.");
+    }
+    if (url == null) {
+      throw new core.ArgumentError("Parameter url is required.");
+    }
+    if (category == null) {
+      throw new core.ArgumentError("Parameter category is required.");
+    }
+    _queryParams["category"] = [category];
+    if (platform == null) {
+      throw new core.ArgumentError("Parameter platform is required.");
+    }
+    _queryParams["platform"] = [platform];
+
+
+    _url = 'sites/' + common_internal.Escaper.ecapeVariable('$siteUrl') + '/urlCrawlErrorsSamples/' + common_internal.Escaper.ecapeVariable('$url');
+
+    var _response = _requester.request(_url,
+                                       "GET",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new UrlCrawlErrorsSample.fromJson(data));
+  }
+
+  /**
+   * Lists a site's sample URLs for the specified crawl error category and
+   * platform.
+   *
+   * Request parameters:
+   *
+   * [siteUrl] - The site's URL, including protocol, for example
+   * 'http://www.example.com/'
+   *
+   * [category] - The crawl error category, for example 'authPermissions'
+   * Possible string values are:
+   * - "authPermissions"
+   * - "manyToOneRedirect"
+   * - "notFollowed"
+   * - "notFound"
+   * - "other"
+   * - "roboted"
+   * - "serverError"
+   * - "soft404"
+   *
+   * [platform] - The user agent type (platform) that made the request, for
+   * example 'web'
+   * Possible string values are:
+   * - "mobile"
+   * - "smartphoneOnly"
+   * - "web"
+   *
+   * Completes with a [UrlCrawlErrorsSamplesListResponse].
+   *
+   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method  will complete with the same error.
+   */
+  async.Future<UrlCrawlErrorsSamplesListResponse> list(core.String siteUrl, core.String category, core.String platform) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (siteUrl == null) {
+      throw new core.ArgumentError("Parameter siteUrl is required.");
+    }
+    if (category == null) {
+      throw new core.ArgumentError("Parameter category is required.");
+    }
+    _queryParams["category"] = [category];
+    if (platform == null) {
+      throw new core.ArgumentError("Parameter platform is required.");
+    }
+    _queryParams["platform"] = [platform];
+
+
+    _url = 'sites/' + common_internal.Escaper.ecapeVariable('$siteUrl') + '/urlCrawlErrorsSamples';
+
+    var _response = _requester.request(_url,
+                                       "GET",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new UrlCrawlErrorsSamplesListResponse.fromJson(data));
+  }
+
+  /**
+   * Marks the provided site's sample URL as fixed, and removes it from the
+   * samples list.
+   *
+   * Request parameters:
+   *
+   * [siteUrl] - The site's URL, including protocol, for example
+   * 'http://www.example.com/'
+   *
+   * [url] - The relative path (without the site) of the sample URL; must be one
+   * of the URLs returned by list
+   *
+   * [category] - The crawl error category, for example 'authPermissions'
+   * Possible string values are:
+   * - "authPermissions"
+   * - "manyToOneRedirect"
+   * - "notFollowed"
+   * - "notFound"
+   * - "other"
+   * - "roboted"
+   * - "serverError"
+   * - "soft404"
+   *
+   * [platform] - The user agent type (platform) that made the request, for
+   * example 'web'
+   * Possible string values are:
+   * - "mobile"
+   * - "smartphoneOnly"
+   * - "web"
+   *
+   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * error.
+   *
+   * If the used [http.Client] completes with an error when making a REST call,
+   * this method  will complete with the same error.
+   */
+  async.Future markAsFixed(core.String siteUrl, core.String url, core.String category, core.String platform) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (siteUrl == null) {
+      throw new core.ArgumentError("Parameter siteUrl is required.");
+    }
+    if (url == null) {
+      throw new core.ArgumentError("Parameter url is required.");
+    }
+    if (category == null) {
+      throw new core.ArgumentError("Parameter category is required.");
+    }
+    _queryParams["category"] = [category];
+    if (platform == null) {
+      throw new core.ArgumentError("Parameter platform is required.");
+    }
+    _queryParams["platform"] = [platform];
+
+    _downloadOptions = null;
+
+    _url = 'sites/' + common_internal.Escaper.ecapeVariable('$siteUrl') + '/urlCrawlErrorsSamples/' + common_internal.Escaper.ecapeVariable('$url');
+
+    var _response = _requester.request(_url,
+                                       "DELETE",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => null);
+  }
+
+}
+
+
+
+/** List of sitemaps. */
+class SitemapsListResponse {
+  /** Information about a sitemap entry. */
+  core.List<WmxSitemap> sitemap;
+
+
+  SitemapsListResponse();
+
+  SitemapsListResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("sitemap")) {
+      sitemap = _json["sitemap"].map((value) => new WmxSitemap.fromJson(value)).toList();
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (sitemap != null) {
+      _json["sitemap"] = sitemap.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}
+
+
+/** List of sites with access level information. */
+class SitesListResponse {
+  /** Access level information for a Webmaster Tools site. */
+  core.List<WmxSite> siteEntry;
+
+
+  SitesListResponse();
+
+  SitesListResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("siteEntry")) {
+      siteEntry = _json["siteEntry"].map((value) => new WmxSite.fromJson(value)).toList();
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (siteEntry != null) {
+      _json["siteEntry"] = siteEntry.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}
+
+
+/** An entry in a URL crawl errors time series. */
+class UrlCrawlErrorCount {
+  /** The error count at the given timestamp. */
+  core.String count;
+
+  /** The time (well, date) when errors were detected, in RFC 3339 format. */
+  core.DateTime timestamp;
+
+
+  UrlCrawlErrorCount();
+
+  UrlCrawlErrorCount.fromJson(core.Map _json) {
+    if (_json.containsKey("count")) {
+      count = _json["count"];
+    }
+    if (_json.containsKey("timestamp")) {
+      timestamp = core.DateTime.parse(_json["timestamp"]);
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (count != null) {
+      _json["count"] = count;
+    }
+    if (timestamp != null) {
+      _json["timestamp"] = (timestamp).toIso8601String();
+    }
+    return _json;
+  }
+}
+
+
+/**
+ * Number of errors per day for a specific error type (defined by platform and
+ * category).
+ */
+class UrlCrawlErrorCountsPerType {
+  /** The crawl error type. */
+  core.String category;
+
+  /** The error count entries time series. */
+  core.List<UrlCrawlErrorCount> entries;
+
+  /** Corresponding to the user agent that made the request. */
+  core.String platform;
+
+
+  UrlCrawlErrorCountsPerType();
+
+  UrlCrawlErrorCountsPerType.fromJson(core.Map _json) {
+    if (_json.containsKey("category")) {
+      category = _json["category"];
+    }
+    if (_json.containsKey("entries")) {
+      entries = _json["entries"].map((value) => new UrlCrawlErrorCount.fromJson(value)).toList();
+    }
+    if (_json.containsKey("platform")) {
+      platform = _json["platform"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (category != null) {
+      _json["category"] = category;
+    }
+    if (entries != null) {
+      _json["entries"] = entries.map((value) => (value).toJson()).toList();
+    }
+    if (platform != null) {
+      _json["platform"] = platform;
+    }
+    return _json;
+  }
+}
+
+
+/**
+ * A time series of the number of URL crawl errors per error category and
+ * platform.
+ */
+class UrlCrawlErrorsCountsQueryResponse {
+  /**
+   * The time series of the number of URL crawl errors for per error category
+   * and platform.
+   */
+  core.List<UrlCrawlErrorCountsPerType> countPerTypes;
+
+
+  UrlCrawlErrorsCountsQueryResponse();
+
+  UrlCrawlErrorsCountsQueryResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("countPerTypes")) {
+      countPerTypes = _json["countPerTypes"].map((value) => new UrlCrawlErrorCountsPerType.fromJson(value)).toList();
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (countPerTypes != null) {
+      _json["countPerTypes"] = countPerTypes.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class UrlCrawlErrorsSample {
+  /** The time the error was first detected, in RFC 3339 format. */
+  core.DateTime firstDetected;
+
+  /** The time when the URL was last crawled, in RFC 3339 format. */
+  core.DateTime lastCrawled;
+
+  /** The URL of an error, relative to the site. */
+  core.String pageUrl;
+
+  /** The HTTP response code, if any. */
+  core.int responseCode;
+
+  /** Additional details about the URL, set only when calling get(). */
+  UrlSampleDetails urlDetails;
+
+
+  UrlCrawlErrorsSample();
+
+  UrlCrawlErrorsSample.fromJson(core.Map _json) {
+    if (_json.containsKey("first_detected")) {
+      firstDetected = core.DateTime.parse(_json["first_detected"]);
+    }
+    if (_json.containsKey("last_crawled")) {
+      lastCrawled = core.DateTime.parse(_json["last_crawled"]);
+    }
+    if (_json.containsKey("pageUrl")) {
+      pageUrl = _json["pageUrl"];
+    }
+    if (_json.containsKey("responseCode")) {
+      responseCode = _json["responseCode"];
+    }
+    if (_json.containsKey("urlDetails")) {
+      urlDetails = new UrlSampleDetails.fromJson(_json["urlDetails"]);
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (firstDetected != null) {
+      _json["first_detected"] = (firstDetected).toIso8601String();
+    }
+    if (lastCrawled != null) {
+      _json["last_crawled"] = (lastCrawled).toIso8601String();
+    }
+    if (pageUrl != null) {
+      _json["pageUrl"] = pageUrl;
+    }
+    if (responseCode != null) {
+      _json["responseCode"] = responseCode;
+    }
+    if (urlDetails != null) {
+      _json["urlDetails"] = (urlDetails).toJson();
+    }
+    return _json;
+  }
+}
+
+
+/** List of crawl error samples. */
+class UrlCrawlErrorsSamplesListResponse {
+  /** Information about the sample URL and its crawl error. */
+  core.List<UrlCrawlErrorsSample> urlCrawlErrorSample;
+
+
+  UrlCrawlErrorsSamplesListResponse();
+
+  UrlCrawlErrorsSamplesListResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("urlCrawlErrorSample")) {
+      urlCrawlErrorSample = _json["urlCrawlErrorSample"].map((value) => new UrlCrawlErrorsSample.fromJson(value)).toList();
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (urlCrawlErrorSample != null) {
+      _json["urlCrawlErrorSample"] = urlCrawlErrorSample.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}
+
+
+/** Additional details about the URL, set only when calling get(). */
+class UrlSampleDetails {
+  /** List of sitemaps pointing at this URL. */
+  core.List<core.String> containingSitemaps;
+
+  /** A sample set of URLs linking to this URL. */
+  core.List<core.String> linkedFromUrls;
+
+
+  UrlSampleDetails();
+
+  UrlSampleDetails.fromJson(core.Map _json) {
+    if (_json.containsKey("containingSitemaps")) {
+      containingSitemaps = _json["containingSitemaps"];
+    }
+    if (_json.containsKey("linkedFromUrls")) {
+      linkedFromUrls = _json["linkedFromUrls"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (containingSitemaps != null) {
+      _json["containingSitemaps"] = containingSitemaps;
+    }
+    if (linkedFromUrls != null) {
+      _json["linkedFromUrls"] = linkedFromUrls;
+    }
+    return _json;
+  }
+}
+
+
+/** Access level information for a Webmaster Tools site. */
+class WmxSite {
+  /** The user's permission level for the site. */
+  core.String permissionLevel;
+
+  /** The URL of the site. */
+  core.String siteUrl;
+
+
+  WmxSite();
+
+  WmxSite.fromJson(core.Map _json) {
+    if (_json.containsKey("permissionLevel")) {
+      permissionLevel = _json["permissionLevel"];
+    }
+    if (_json.containsKey("siteUrl")) {
+      siteUrl = _json["siteUrl"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (permissionLevel != null) {
+      _json["permissionLevel"] = permissionLevel;
+    }
+    if (siteUrl != null) {
+      _json["siteUrl"] = siteUrl;
+    }
+    return _json;
+  }
+}
+
+
+/** Not documented yet. */
+class WmxSitemap {
+  /** The various content types in the sitemap. */
+  core.List<WmxSitemapContent> contents;
+
+  /**
+   * Number of errors in the sitemap - issues with the sitemap itself, that
+   * needs to be fixed before it can be processed correctly.
+   */
+  core.String errors;
+
+  /** If true, the sitemap has not been processed. */
+  core.bool isPending;
+
+  /** If true, the sitemap is a collection of sitemaps. */
+  core.bool isSitemapsIndex;
+
+  /**
+   * Date & time in which this sitemap was last downloaded. Date format is in
+   * RFC 3339 format (yyyy-mm-dd).
+   */
+  core.DateTime lastDownloaded;
+
+  /**
+   * Date & time in which this sitemap was submitted. Date format is in RFC 3339
+   * format (yyyy-mm-dd).
+   */
+  core.DateTime lastSubmitted;
+
+  /** The url of the sitemap. */
+  core.String path;
+
+  /** The type of the sitemap (for example "sitemap"). */
+  core.String type;
+
+  /** Number of warnings for the sitemap - issues with URLs in the sitemaps. */
+  core.String warnings;
+
+
+  WmxSitemap();
+
+  WmxSitemap.fromJson(core.Map _json) {
+    if (_json.containsKey("contents")) {
+      contents = _json["contents"].map((value) => new WmxSitemapContent.fromJson(value)).toList();
+    }
+    if (_json.containsKey("errors")) {
+      errors = _json["errors"];
+    }
+    if (_json.containsKey("isPending")) {
+      isPending = _json["isPending"];
+    }
+    if (_json.containsKey("isSitemapsIndex")) {
+      isSitemapsIndex = _json["isSitemapsIndex"];
+    }
+    if (_json.containsKey("lastDownloaded")) {
+      lastDownloaded = core.DateTime.parse(_json["lastDownloaded"]);
+    }
+    if (_json.containsKey("lastSubmitted")) {
+      lastSubmitted = core.DateTime.parse(_json["lastSubmitted"]);
+    }
+    if (_json.containsKey("path")) {
+      path = _json["path"];
+    }
+    if (_json.containsKey("type")) {
+      type = _json["type"];
+    }
+    if (_json.containsKey("warnings")) {
+      warnings = _json["warnings"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (contents != null) {
+      _json["contents"] = contents.map((value) => (value).toJson()).toList();
+    }
+    if (errors != null) {
+      _json["errors"] = errors;
+    }
+    if (isPending != null) {
+      _json["isPending"] = isPending;
+    }
+    if (isSitemapsIndex != null) {
+      _json["isSitemapsIndex"] = isSitemapsIndex;
+    }
+    if (lastDownloaded != null) {
+      _json["lastDownloaded"] = (lastDownloaded).toIso8601String();
+    }
+    if (lastSubmitted != null) {
+      _json["lastSubmitted"] = (lastSubmitted).toIso8601String();
+    }
+    if (path != null) {
+      _json["path"] = path;
+    }
+    if (type != null) {
+      _json["type"] = type;
+    }
+    if (warnings != null) {
+      _json["warnings"] = warnings;
+    }
+    return _json;
+  }
+}
+
+
+/** Information about the various content types in the sitemap. */
+class WmxSitemapContent {
+  /**
+   * The number of URLs from the sitemap that were indexed (of the content
+   * type).
+   */
+  core.String indexed;
+
+  /** The number of URLs in the sitemap (of the content type). */
+  core.String submitted;
+
+  /**
+   * The specific type of content in this sitemap (for example "web", "images").
+   */
+  core.String type;
+
+
+  WmxSitemapContent();
+
+  WmxSitemapContent.fromJson(core.Map _json) {
+    if (_json.containsKey("indexed")) {
+      indexed = _json["indexed"];
+    }
+    if (_json.containsKey("submitted")) {
+      submitted = _json["submitted"];
+    }
+    if (_json.containsKey("type")) {
+      type = _json["type"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (indexed != null) {
+      _json["indexed"] = indexed;
+    }
+    if (submitted != null) {
+      _json["submitted"] = submitted;
+    }
+    if (type != null) {
+      _json["type"] = type;
+    }
+    return _json;
+  }
+}
+
+