Roll of googleapis as of 4/7/2015.

generated/googleapis/lib/bigquery/v2.dart

+// This is a generated file (see the discoveryapis_generator project).
+
 library googleapis.bigquery.v2;
 
-import "dart:core" as core;
-import "dart:collection" as collection;
-import "dart:async" as async;
-import "dart:convert" as convert;
+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:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
+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;
+export 'package:_discoveryapis_commons/_discoveryapis_commons.dart' show
+    ApiRequestError, DetailedApiRequestError, Media, UploadOptions,
+    ResumableUploadOptions, DownloadOptions, PartialDownloadOptions,
+    ByteRange;
+
+const core.String USER_AGENT = 'dart-api-client bigquery/v2';
 
 /** A data platform for customers to create, manage, share and query data. */
 class BigqueryApi {
   /** View and manage your data in Google BigQuery */
   static const BigqueryScope = "https://www.googleapis.com/auth/bigquery";
 
   /** Insert data into Google BigQuery */
   static const BigqueryInsertdataScope = "https://www.googleapis.com/auth/bigquery.insertdata";
 
   /** View and manage your data across Google Cloud Platform services */
   static const CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform";
 
   /** Manage your data and permissions in Google Cloud Storage */
   static const DevstorageFullControlScope = "https://www.googleapis.com/auth/devstorage.full_control";
 
   /** View your data in Google Cloud Storage */
   static const DevstorageReadOnlyScope = "https://www.googleapis.com/auth/devstorage.read_only";
 
   /** Manage your data in Google Cloud Storage */
   static const DevstorageReadWriteScope = "https://www.googleapis.com/auth/devstorage.read_write";
 
 
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
   DatasetsResourceApi get datasets => new DatasetsResourceApi(_requester);
   JobsResourceApi get jobs => new JobsResourceApi(_requester);
   ProjectsResourceApi get projects => new ProjectsResourceApi(_requester);
   TabledataResourceApi get tabledata => new TabledataResourceApi(_requester);
   TablesResourceApi get tables => new TablesResourceApi(_requester);
 
   BigqueryApi(http.Client client, {core.String rootUrl: "https://www.googleapis.com/", core.String servicePath: "bigquery/v2/"}) :
-      _requester = new common_internal.ApiRequester(client, rootUrl, servicePath);
+      _requester = new commons.ApiRequester(client, rootUrl, servicePath, USER_AGENT);
 }
 
 
-/** Not documented yet. */
 class DatasetsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  DatasetsResourceApi(common_internal.ApiRequester client) : 
+  DatasetsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Deletes the dataset specified by the datasetId value. Before you can delete
    * a dataset, you must delete all its tables, either manually or by specifying
    * deleteContents. Immediately after deletion, you can create another dataset
    * with the same name.
    *
    * Request parameters:
    *
    * [projectId] - Project ID of the dataset being deleted
    *
    * [datasetId] - Dataset ID of dataset being deleted
    *
    * [deleteContents] - If True, delete all the tables in the dataset. If False
    * and the dataset contains tables, the request will fail. Default is False
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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 projectId, core.String datasetId, {core.bool deleteContents}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
     if (datasetId == null) {
       throw new core.ArgumentError("Parameter datasetId is required.");
     }
     if (deleteContents != null) {
       _queryParams["deleteContents"] = ["${deleteContents}"];
     }
 
     _downloadOptions = null;
 
-    _url = 'projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/datasets/' + common_internal.Escaper.ecapeVariable('$datasetId');
+    _url = 'projects/' + commons.Escaper.ecapeVariable('$projectId') + '/datasets/' + commons.Escaper.ecapeVariable('$datasetId');
 
     var _response = _requester.request(_url,
                                        "DELETE",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
 
   /**
    * Returns the dataset specified by datasetID.
    *
    * Request parameters:
    *
    * [projectId] - Project ID of the requested dataset
    *
    * [datasetId] - Dataset ID of the requested dataset
    *
    * Completes with a [Dataset].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Dataset> get(core.String projectId, core.String datasetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
     if (datasetId == null) {
       throw new core.ArgumentError("Parameter datasetId is required.");
     }
 
 
-    _url = 'projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/datasets/' + common_internal.Escaper.ecapeVariable('$datasetId');
+    _url = 'projects/' + commons.Escaper.ecapeVariable('$projectId') + '/datasets/' + commons.Escaper.ecapeVariable('$datasetId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Dataset.fromJson(data));
   }
 
   /**
    * Creates a new empty dataset.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [projectId] - Project ID of the new dataset
    *
    * Completes with a [Dataset].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Dataset> insert(Dataset request, core.String projectId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
 
 
-    _url = 'projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/datasets';
+    _url = 'projects/' + commons.Escaper.ecapeVariable('$projectId') + '/datasets';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Dataset.fromJson(data));
   }
 
   /**
    * Lists all the datasets in the specified project to which the caller has
    * read access; however, a project owner can list (but not necessarily get)
    * all datasets in his project.
    *
    * Request parameters:
    *
    * [projectId] - Project ID of the datasets to be listed
    *
    * [all] - Whether to list all datasets, including hidden ones
    *
    * [maxResults] - The maximum number of results to return
    *
    * [pageToken] - Page token, returned by a previous call, to request the next
    * page of results
    *
    * Completes with a [DatasetList].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<DatasetList> list(core.String projectId, {core.bool all, core.int maxResults, core.String pageToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
     if (all != null) {
       _queryParams["all"] = ["${all}"];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
 
-    _url = 'projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/datasets';
+    _url = 'projects/' + commons.Escaper.ecapeVariable('$projectId') + '/datasets';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new DatasetList.fromJson(data));
   }
 
   /**
    * Updates information in an existing dataset. The update method replaces the
    * entire dataset resource, whereas the patch method only replaces fields that
    * are provided in the submitted dataset resource. This method supports patch
    * semantics.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [projectId] - Project ID of the dataset being updated
    *
    * [datasetId] - Dataset ID of the dataset being updated
    *
    * Completes with a [Dataset].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Dataset> patch(Dataset request, core.String projectId, core.String datasetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
     if (datasetId == null) {
       throw new core.ArgumentError("Parameter datasetId is required.");
     }
 
 
-    _url = 'projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/datasets/' + common_internal.Escaper.ecapeVariable('$datasetId');
+    _url = 'projects/' + commons.Escaper.ecapeVariable('$projectId') + '/datasets/' + commons.Escaper.ecapeVariable('$datasetId');
 
     var _response = _requester.request(_url,
                                        "PATCH",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Dataset.fromJson(data));
   }
 
   /**
    * Updates information in an existing dataset. The update method replaces the
    * entire dataset resource, whereas the patch method only replaces fields that
    * are provided in the submitted dataset resource.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [projectId] - Project ID of the dataset being updated
    *
    * [datasetId] - Dataset ID of the dataset being updated
    *
    * Completes with a [Dataset].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Dataset> update(Dataset request, core.String projectId, core.String datasetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
     if (datasetId == null) {
       throw new core.ArgumentError("Parameter datasetId is required.");
     }
 
 
-    _url = 'projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/datasets/' + common_internal.Escaper.ecapeVariable('$datasetId');
+    _url = 'projects/' + commons.Escaper.ecapeVariable('$projectId') + '/datasets/' + commons.Escaper.ecapeVariable('$datasetId');
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Dataset.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class JobsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  JobsResourceApi(common_internal.ApiRequester client) : 
+  JobsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Retrieves the specified job by ID.
    *
    * Request parameters:
    *
    * [projectId] - Project ID of the requested job
    *
    * [jobId] - Job ID of the requested job
    *
    * Completes with a [Job].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Job> get(core.String projectId, core.String jobId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
     if (jobId == null) {
       throw new core.ArgumentError("Parameter jobId is required.");
     }
 
 
-    _url = 'projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/jobs/' + common_internal.Escaper.ecapeVariable('$jobId');
+    _url = 'projects/' + commons.Escaper.ecapeVariable('$projectId') + '/jobs/' + commons.Escaper.ecapeVariable('$jobId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Job.fromJson(data));
   }
@@ skipping 13 matching lines @@
    * page of results
    *
    * [startIndex] - Zero-based index of the starting row
    *
    * [timeoutMs] - How long to wait for the query to complete, in milliseconds,
    * before returning. Default is to return immediately. If the timeout passes
    * before the job completes, the request will fail with a TIMEOUT error
    *
    * Completes with a [GetQueryResultsResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<GetQueryResultsResponse> getQueryResults(core.String projectId, core.String jobId, {core.int maxResults, core.String pageToken, core.String startIndex, core.int timeoutMs}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
     if (jobId == null) {
       throw new core.ArgumentError("Parameter jobId is required.");
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
     if (startIndex != null) {
       _queryParams["startIndex"] = [startIndex];
     }
     if (timeoutMs != null) {
       _queryParams["timeoutMs"] = ["${timeoutMs}"];
     }
 
 
-    _url = 'projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/queries/' + common_internal.Escaper.ecapeVariable('$jobId');
+    _url = 'projects/' + commons.Escaper.ecapeVariable('$projectId') + '/queries/' + commons.Escaper.ecapeVariable('$jobId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new GetQueryResultsResponse.fromJson(data));
   }
 
   /**
    * Starts a new asynchronous job.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [projectId] - Project ID of the project that will be billed for the job
    *
    * [uploadMedia] - The media to upload.
    *
    * [uploadOptions] - Options for the media upload. Streaming Media without the
    * length being known ahead of time is only supported via resumable uploads.
    *
    * Completes with a [Job].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Job> insert(Job request, core.String projectId, {common.UploadOptions uploadOptions : common.UploadOptions.Default, common.Media uploadMedia}) {
+  async.Future<Job> insert(Job request, core.String projectId, {commons.UploadOptions uploadOptions : commons.UploadOptions.Default, commons.Media uploadMedia}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
 
     _uploadMedia =  uploadMedia;
     _uploadOptions =  uploadOptions;
 
     if (_uploadMedia == null) {
-      _url = 'projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/jobs';
-    } else if (_uploadOptions is common.ResumableUploadOptions) {
-      _url = '/resumable/upload/bigquery/v2/projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/jobs';
+      _url = 'projects/' + commons.Escaper.ecapeVariable('$projectId') + '/jobs';
+    } else if (_uploadOptions is commons.ResumableUploadOptions) {
+      _url = '/resumable/upload/bigquery/v2/projects/' + commons.Escaper.ecapeVariable('$projectId') + '/jobs';
     } else {
-      _url = '/upload/bigquery/v2/projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/jobs';
+      _url = '/upload/bigquery/v2/projects/' + commons.Escaper.ecapeVariable('$projectId') + '/jobs';
     }
 
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 19 matching lines @@
    *
    * [projection] - Restrict information returned to a set of selected fields
    * Possible string values are:
    * - "full" : Includes all job data
    * - "minimal" : Does not include the job configuration
    *
    * [stateFilter] - Filter for job state
    *
    * Completes with a [JobList].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<JobList> list(core.String projectId, {core.bool allUsers, core.int maxResults, core.String pageToken, core.String projection, core.List<core.String> stateFilter}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
     if (allUsers != null) {
       _queryParams["allUsers"] = ["${allUsers}"];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
     if (projection != null) {
       _queryParams["projection"] = [projection];
     }
     if (stateFilter != null) {
       _queryParams["stateFilter"] = stateFilter;
     }
 
 
-    _url = 'projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/jobs';
+    _url = 'projects/' + commons.Escaper.ecapeVariable('$projectId') + '/jobs';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new JobList.fromJson(data));
   }
 
   /**
    * Runs a BigQuery SQL query synchronously and returns query results if the
    * query completes within a specified timeout.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [projectId] - Project ID of the project billed for the query
    *
    * Completes with a [QueryResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<QueryResponse> query(QueryRequest request, core.String projectId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
 
 
-    _url = 'projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/queries';
+    _url = 'projects/' + commons.Escaper.ecapeVariable('$projectId') + '/queries';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new QueryResponse.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class ProjectsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  ProjectsResourceApi(common_internal.ApiRequester client) : 
+  ProjectsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Lists the projects to which you have at least read access.
    *
    * Request parameters:
    *
    * [maxResults] - Maximum number of results to return
    *
    * [pageToken] - Page token, returned by a previous call, to request the next
    * page of results
    *
    * Completes with a [ProjectList].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<ProjectList> list({core.int maxResults, core.String pageToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
 
     _url = 'projects';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ProjectList.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class TabledataResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  TabledataResourceApi(common_internal.ApiRequester client) : 
+  TabledataResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Streams data into BigQuery one record at a time without needing to run a
    * load job.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [projectId] - Project ID of the destination table.
    *
    * [datasetId] - Dataset ID of the destination table.
    *
    * [tableId] - Table ID of the destination table.
    *
    * Completes with a [TableDataInsertAllResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<TableDataInsertAllResponse> insertAll(TableDataInsertAllRequest request, core.String projectId, core.String datasetId, core.String tableId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
     if (datasetId == null) {
       throw new core.ArgumentError("Parameter datasetId is required.");
     }
     if (tableId == null) {
       throw new core.ArgumentError("Parameter tableId is required.");
     }
 
 
-    _url = 'projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/datasets/' + common_internal.Escaper.ecapeVariable('$datasetId') + '/tables/' + common_internal.Escaper.ecapeVariable('$tableId') + '/insertAll';
+    _url = 'projects/' + commons.Escaper.ecapeVariable('$projectId') + '/datasets/' + commons.Escaper.ecapeVariable('$datasetId') + '/tables/' + commons.Escaper.ecapeVariable('$tableId') + '/insertAll';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new TableDataInsertAllResponse.fromJson(data));
   }
@@ skipping 11 matching lines @@
    *
    * [maxResults] - Maximum number of results to return
    *
    * [pageToken] - Page token, returned by a previous call, identifying the
    * result set
    *
    * [startIndex] - Zero-based index of the starting row to read
    *
    * Completes with a [TableDataList].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<TableDataList> list(core.String projectId, core.String datasetId, core.String tableId, {core.int maxResults, core.String pageToken, core.String startIndex}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
     if (datasetId == null) {
       throw new core.ArgumentError("Parameter datasetId is required.");
     }
     if (tableId == null) {
       throw new core.ArgumentError("Parameter tableId is required.");
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
     if (startIndex != null) {
       _queryParams["startIndex"] = [startIndex];
     }
 
 
-    _url = 'projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/datasets/' + common_internal.Escaper.ecapeVariable('$datasetId') + '/tables/' + common_internal.Escaper.ecapeVariable('$tableId') + '/data';
+    _url = 'projects/' + commons.Escaper.ecapeVariable('$projectId') + '/datasets/' + commons.Escaper.ecapeVariable('$datasetId') + '/tables/' + commons.Escaper.ecapeVariable('$tableId') + '/data';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new TableDataList.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class TablesResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  TablesResourceApi(common_internal.ApiRequester client) : 
+  TablesResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Deletes the table specified by tableId from the dataset. If the table
    * contains data, all the data will be deleted.
    *
    * Request parameters:
    *
    * [projectId] - Project ID of the table to delete
    *
    * [datasetId] - Dataset ID of the table to delete
    *
    * [tableId] - Table ID of the table to delete
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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 projectId, core.String datasetId, core.String tableId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
     if (datasetId == null) {
       throw new core.ArgumentError("Parameter datasetId is required.");
     }
     if (tableId == null) {
       throw new core.ArgumentError("Parameter tableId is required.");
     }
 
     _downloadOptions = null;
 
-    _url = 'projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/datasets/' + common_internal.Escaper.ecapeVariable('$datasetId') + '/tables/' + common_internal.Escaper.ecapeVariable('$tableId');
+    _url = 'projects/' + commons.Escaper.ecapeVariable('$projectId') + '/datasets/' + commons.Escaper.ecapeVariable('$datasetId') + '/tables/' + commons.Escaper.ecapeVariable('$tableId');
 
     var _response = _requester.request(_url,
                                        "DELETE",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
 
   /**
    * Gets the specified table resource by table ID. This method does not return
    * the data in the table, it only returns the table resource, which describes
    * the structure of this table.
    *
    * Request parameters:
    *
    * [projectId] - Project ID of the requested table
    *
    * [datasetId] - Dataset ID of the requested table
    *
    * [tableId] - Table ID of the requested table
    *
    * Completes with a [Table].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Table> get(core.String projectId, core.String datasetId, core.String tableId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
     if (datasetId == null) {
       throw new core.ArgumentError("Parameter datasetId is required.");
     }
     if (tableId == null) {
       throw new core.ArgumentError("Parameter tableId is required.");
     }
 
 
-    _url = 'projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/datasets/' + common_internal.Escaper.ecapeVariable('$datasetId') + '/tables/' + common_internal.Escaper.ecapeVariable('$tableId');
+    _url = 'projects/' + commons.Escaper.ecapeVariable('$projectId') + '/datasets/' + commons.Escaper.ecapeVariable('$datasetId') + '/tables/' + commons.Escaper.ecapeVariable('$tableId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Table.fromJson(data));
   }
 
   /**
    * Creates a new, empty table in the dataset.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [projectId] - Project ID of the new table
    *
    * [datasetId] - Dataset ID of the new table
    *
    * Completes with a [Table].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Table> insert(Table request, core.String projectId, core.String datasetId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
     if (datasetId == null) {
       throw new core.ArgumentError("Parameter datasetId is required.");
     }
 
 
-    _url = 'projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/datasets/' + common_internal.Escaper.ecapeVariable('$datasetId') + '/tables';
+    _url = 'projects/' + commons.Escaper.ecapeVariable('$projectId') + '/datasets/' + commons.Escaper.ecapeVariable('$datasetId') + '/tables';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Table.fromJson(data));
   }
 
   /**
    * Lists all tables in the specified dataset.
    *
    * Request parameters:
    *
    * [projectId] - Project ID of the tables to list
    *
    * [datasetId] - Dataset ID of the tables to list
    *
    * [maxResults] - Maximum number of results to return
    *
    * [pageToken] - Page token, returned by a previous call, to request the next
    * page of results
    *
    * Completes with a [TableList].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<TableList> list(core.String projectId, core.String datasetId, {core.int maxResults, core.String pageToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
     if (datasetId == null) {
       throw new core.ArgumentError("Parameter datasetId is required.");
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
 
-    _url = 'projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/datasets/' + common_internal.Escaper.ecapeVariable('$datasetId') + '/tables';
+    _url = 'projects/' + commons.Escaper.ecapeVariable('$projectId') + '/datasets/' + commons.Escaper.ecapeVariable('$datasetId') + '/tables';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new TableList.fromJson(data));
   }
 
   /**
    * Updates information in an existing table. The update method replaces the
    * entire table resource, whereas the patch method only replaces fields that
    * are provided in the submitted table resource. This method supports patch
    * semantics.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [projectId] - Project ID of the table to update
    *
    * [datasetId] - Dataset ID of the table to update
    *
    * [tableId] - Table ID of the table to update
    *
    * Completes with a [Table].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Table> patch(Table request, core.String projectId, core.String datasetId, core.String tableId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
     if (datasetId == null) {
       throw new core.ArgumentError("Parameter datasetId is required.");
     }
     if (tableId == null) {
       throw new core.ArgumentError("Parameter tableId is required.");
     }
 
 
-    _url = 'projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/datasets/' + common_internal.Escaper.ecapeVariable('$datasetId') + '/tables/' + common_internal.Escaper.ecapeVariable('$tableId');
+    _url = 'projects/' + commons.Escaper.ecapeVariable('$projectId') + '/datasets/' + commons.Escaper.ecapeVariable('$datasetId') + '/tables/' + commons.Escaper.ecapeVariable('$tableId');
 
     var _response = _requester.request(_url,
                                        "PATCH",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Table.fromJson(data));
   }
 
   /**
    * Updates information in an existing table. The update method replaces the
    * entire table resource, whereas the patch method only replaces fields that
    * are provided in the submitted table resource.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [projectId] - Project ID of the table to update
    *
    * [datasetId] - Dataset ID of the table to update
    *
    * [tableId] - Table ID of the table to update
    *
    * Completes with a [Table].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * Completes with a [commons.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<Table> update(Table request, core.String projectId, core.String datasetId, core.String tableId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
     if (datasetId == null) {
       throw new core.ArgumentError("Parameter datasetId is required.");
     }
     if (tableId == null) {
       throw new core.ArgumentError("Parameter tableId is required.");
     }
 
 
-    _url = 'projects/' + common_internal.Escaper.ecapeVariable('$projectId') + '/datasets/' + common_internal.Escaper.ecapeVariable('$datasetId') + '/tables/' + common_internal.Escaper.ecapeVariable('$tableId');
+    _url = 'projects/' + commons.Escaper.ecapeVariable('$projectId') + '/datasets/' + commons.Escaper.ecapeVariable('$datasetId') + '/tables/' + commons.Escaper.ecapeVariable('$tableId');
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Table.fromJson(data));
   }
 
 }
 
 
 
-/** Not documented yet. */
+class CsvOptions {
+  /**
+   * [Optional] Indicates if BigQuery should accept rows that are missing
+   * trailing optional columns. If true, BigQuery treats missing trailing
+   * columns as null values. If false, records with missing trailing columns are
+   * treated as bad records, and if there are too many bad records, an invalid
+   * error is returned in the job result. The default value is false.
+   */
+  core.bool allowJaggedRows;
+
+  /**
+   * [Optional] Indicates if BigQuery should allow quoted data sections that
+   * contain newline characters in a CSV file. The default value is false.
+   */
+  core.bool allowQuotedNewlines;
+
+  /**
+   * [Optional] The character encoding of the data. The supported values are
+   * UTF-8 or ISO-8859-1. The default value is UTF-8. BigQuery decodes the data
+   * after the raw, binary data has been split using the values of the quote and
+   * fieldDelimiter properties.
+   */
+  core.String encoding;
+
+  /**
+   * [Optional] The separator for fields in a CSV file. BigQuery converts the
+   * string to ISO-8859-1 encoding, and then uses the first byte of the encoded
+   * string to split the data in its raw, binary state. BigQuery also supports
+   * the escape sequence "\t" to specify a tab separator. The default value is a
+   * comma (',').
+   */
+  core.String fieldDelimiter;
+
+  /**
+   * [Optional] The value that is used to quote data sections in a CSV file.
+   * BigQuery converts the string to ISO-8859-1 encoding, and then uses the
+   * first byte of the encoded string to split the data in its raw, binary
+   * state. The default value is a double-quote ('"'). If your data does not
+   * contain quoted sections, set the property value to an empty string. If your
+   * data contains quoted newline characters, you must also set the
+   * allowQuotedNewlines property to true.
+   */
+  core.String quote;
+
+  /**
+   * [Optional] The number of rows at the top of a CSV file that BigQuery will
+   * skip when reading the data. The default value is 0. This property is useful
+   * if you have header rows in the file that should be skipped.
+   */
+  core.int skipLeadingRows;
+
+
+  CsvOptions();
+
+  CsvOptions.fromJson(core.Map _json) {
+    if (_json.containsKey("allowJaggedRows")) {
+      allowJaggedRows = _json["allowJaggedRows"];
+    }
+    if (_json.containsKey("allowQuotedNewlines")) {
+      allowQuotedNewlines = _json["allowQuotedNewlines"];
+    }
+    if (_json.containsKey("encoding")) {
+      encoding = _json["encoding"];
+    }
+    if (_json.containsKey("fieldDelimiter")) {
+      fieldDelimiter = _json["fieldDelimiter"];
+    }
+    if (_json.containsKey("quote")) {
+      quote = _json["quote"];
+    }
+    if (_json.containsKey("skipLeadingRows")) {
+      skipLeadingRows = _json["skipLeadingRows"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (allowJaggedRows != null) {
+      _json["allowJaggedRows"] = allowJaggedRows;
+    }
+    if (allowQuotedNewlines != null) {
+      _json["allowQuotedNewlines"] = allowQuotedNewlines;
+    }
+    if (encoding != null) {
+      _json["encoding"] = encoding;
+    }
+    if (fieldDelimiter != null) {
+      _json["fieldDelimiter"] = fieldDelimiter;
+    }
+    if (quote != null) {
+      _json["quote"] = quote;
+    }
+    if (skipLeadingRows != null) {
+      _json["skipLeadingRows"] = skipLeadingRows;
+    }
+    return _json;
+  }
+}
+
+
 class DatasetAccess {
   /**
    * [Pick one] A domain to grant access to. Any users signed in with the domain
    * specified will be granted the specified access. Example: "example.com".
    */
   core.String domain;
 
   /** [Pick one] An email address of a Google Group to grant access to. */
   core.String groupByEmail;
 
@@ skipping 69 matching lines @@
       _json["userByEmail"] = userByEmail;
     }
     if (view != null) {
       _json["view"] = (view).toJson();
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class Dataset {
   /**
    * [Optional] An array of objects that define dataset access for one or more
    * entities. You can set this property when inserting or updating a dataset in
    * order to control who is allowed to access the data. If unspecified at
    * dataset creation time, BigQuery adds default dataset access for the
    * following entities: access.specialGroup: projectReaders; access.role:
    * READER; access.specialGroup: projectWriters; access.role: WRITER;
    * access.specialGroup: projectOwners; access.role: OWNER; access.userByEmail:
    * [dataset creator email]; access.role: OWNER;
    */
   core.List<DatasetAccess> access;
 
   /**
    * [Output-only] The time when this dataset was created, in milliseconds since
    * the epoch.
    */
   core.String creationTime;
 
   /** [Required] A reference that identifies the dataset. */
   DatasetReference datasetReference;
 
+  /**
+   * [Experimental] The default lifetime of all tables in the dataset, in
+   * milliseconds. The minimum value is 3600000 milliseconds (one hour). Once
+   * this property is set, all newly-created tables in the dataset will have an
+   * expirationTime property set to the creation time plus the value in this
+   * property, and changing the value will only affect new tables, not existing
+   * ones. When the expirationTime for a given table is reached, that table will
+   * be deleted automatically. If a table's expirationTime is modified or
+   * removed before the table expires, or if you provide an explicit
+   * expirationTime when creating a table, that value takes precedence over the
+   * default expiration time indicated by this property.
+   */
+  core.String defaultTableExpirationMs;
+
   /** [Optional] A user-friendly description of the dataset. */
   core.String description;
 
   /** [Output-only] A hash of the resource. */
   core.String etag;
 
   /** [Optional] A descriptive name for the dataset. */
   core.String friendlyName;
 
   /**
@@ skipping 25 matching lines @@
   Dataset.fromJson(core.Map _json) {
     if (_json.containsKey("access")) {
       access = _json["access"].map((value) => new DatasetAccess.fromJson(value)).toList();
     }
     if (_json.containsKey("creationTime")) {
       creationTime = _json["creationTime"];
     }
     if (_json.containsKey("datasetReference")) {
       datasetReference = new DatasetReference.fromJson(_json["datasetReference"]);
     }
+    if (_json.containsKey("defaultTableExpirationMs")) {
+      defaultTableExpirationMs = _json["defaultTableExpirationMs"];
+    }
     if (_json.containsKey("description")) {
       description = _json["description"];
     }
     if (_json.containsKey("etag")) {
       etag = _json["etag"];
     }
     if (_json.containsKey("friendlyName")) {
       friendlyName = _json["friendlyName"];
     }
     if (_json.containsKey("id")) {
@@ skipping 14 matching lines @@
     var _json = new core.Map();
     if (access != null) {
       _json["access"] = access.map((value) => (value).toJson()).toList();
     }
     if (creationTime != null) {
       _json["creationTime"] = creationTime;
     }
     if (datasetReference != null) {
       _json["datasetReference"] = (datasetReference).toJson();
     }
+    if (defaultTableExpirationMs != null) {
+      _json["defaultTableExpirationMs"] = defaultTableExpirationMs;
+    }
     if (description != null) {
       _json["description"] = description;
     }
     if (etag != null) {
       _json["etag"] = etag;
     }
     if (friendlyName != null) {
       _json["friendlyName"] = friendlyName;
     }
     if (id != null) {
       _json["id"] = id;
     }
     if (kind != null) {
       _json["kind"] = kind;
     }
     if (lastModifiedTime != null) {
       _json["lastModifiedTime"] = lastModifiedTime;
     }
     if (selfLink != null) {
       _json["selfLink"] = selfLink;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class DatasetListDatasets {
   /**
    * The dataset reference. Use this property to access specific parts of the
    * dataset's ID, such as project ID or dataset ID.
    */
   DatasetReference datasetReference;
 
   /** A descriptive name for the dataset, if one exists. */
   core.String friendlyName;
 
@@ skipping 36 matching lines @@
       _json["id"] = id;
     }
     if (kind != null) {
       _json["kind"] = kind;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class DatasetList {
   /**
    * An array of the dataset resources in the project. Each resource contains
    * basic information. For full information about a particular dataset
    * resource, use the Datasets: get method. This property is omitted when there
    * are no datasets in the project.
    */
   core.List<DatasetListDatasets> datasets;
 
   /**
@@ skipping 44 matching lines @@
       _json["kind"] = kind;
     }
     if (nextPageToken != null) {
       _json["nextPageToken"] = nextPageToken;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class DatasetReference {
   /**
    * [Required] A unique ID for this dataset, without the project name. The ID
    * must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_).
    * The maximum length is 1,024 characters.
    */
   core.String datasetId;
 
   /** [Optional] The ID of the project containing this dataset. */
   core.String projectId;
@@ skipping 16 matching lines @@
       _json["datasetId"] = datasetId;
     }
     if (projectId != null) {
       _json["projectId"] = projectId;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class ErrorProto {
   /**
    * Debugging information. This property is internal to Google and should not
    * be used.
    */
   core.String debugInfo;
 
   /** Specifies where the error occurred, if present. */
   core.String location;
 
@@ skipping 33 matching lines @@
       _json["message"] = message;
     }
     if (reason != null) {
       _json["reason"] = reason;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
+class ExternalDataConfiguration {
+  /**
+   * [Optional] The compression type of the data source. Possible values include
+   * GZIP and NONE. The default value is NONE.
+   */
+  core.String compression;
+
+  /** Additional properties to set if sourceFormat is set to CSV. */
+  CsvOptions csvOptions;
+
+  /**
+   * [Optional] Indicates if BigQuery should allow extra values that are not
+   * represented in the table schema. If true, the extra values are ignored. If
+   * false, records with extra columns are treated as bad records, and if there
+   * are too many bad records, an invalid error is returned in the job result.
+   * The default value is false. The sourceFormat property determines what
+   * BigQuery treats as an extra value: CSV: Trailing columns
+   */
+  core.bool ignoreUnknownValues;
+
+  /**
+   * [Optional] The maximum number of bad records that BigQuery can ignore when
+   * reading data. If the number of bad records exceeds this value, an invalid
+   * error is returned in the job result. The default value is 0, which requires
+   * that all records are valid.
+   */
+  core.int maxBadRecords;
+
+  /** [Required] The schema for the data. */
+  TableSchema schema;
+
+  /**
+   * [Optional] The data format. External data sources must be in CSV format.
+   * The default value is CSV.
+   */
+  core.String sourceFormat;
+
+  /**
+   * [Required] The fully-qualified URIs that point to your data in Google Cloud
+   * Storage. Each URI can contain one '*' wildcard character and it must come
+   * after the 'bucket' name. CSV limits related to load jobs apply to external
+   * data sources, plus an additional limit of 10 GB maximum size across all
+   * URIs.
+   */
+  core.List<core.String> sourceUris;
+
+
+  ExternalDataConfiguration();
+
+  ExternalDataConfiguration.fromJson(core.Map _json) {
+    if (_json.containsKey("compression")) {
+      compression = _json["compression"];
+    }
+    if (_json.containsKey("csvOptions")) {
+      csvOptions = new CsvOptions.fromJson(_json["csvOptions"]);
+    }
+    if (_json.containsKey("ignoreUnknownValues")) {
+      ignoreUnknownValues = _json["ignoreUnknownValues"];
+    }
+    if (_json.containsKey("maxBadRecords")) {
+      maxBadRecords = _json["maxBadRecords"];
+    }
+    if (_json.containsKey("schema")) {
+      schema = new TableSchema.fromJson(_json["schema"]);
+    }
+    if (_json.containsKey("sourceFormat")) {
+      sourceFormat = _json["sourceFormat"];
+    }
+    if (_json.containsKey("sourceUris")) {
+      sourceUris = _json["sourceUris"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (compression != null) {
+      _json["compression"] = compression;
+    }
+    if (csvOptions != null) {
+      _json["csvOptions"] = (csvOptions).toJson();
+    }
+    if (ignoreUnknownValues != null) {
+      _json["ignoreUnknownValues"] = ignoreUnknownValues;
+    }
+    if (maxBadRecords != null) {
+      _json["maxBadRecords"] = maxBadRecords;
+    }
+    if (schema != null) {
+      _json["schema"] = (schema).toJson();
+    }
+    if (sourceFormat != null) {
+      _json["sourceFormat"] = sourceFormat;
+    }
+    if (sourceUris != null) {
+      _json["sourceUris"] = sourceUris;
+    }
+    return _json;
+  }
+}
+
+
 class GetQueryResultsResponse {
   /** Whether the query result was fetched from the query cache. */
   core.bool cacheHit;
 
   /** A hash of this response. */
   core.String etag;
 
   /**
    * Whether the query has completed or not. If rows or totalRows are present,
    * this will always be true. If this is false, totalRows will not be
@@ skipping 106 matching lines @@
       _json["totalBytesProcessed"] = totalBytesProcessed;
     }
     if (totalRows != null) {
       _json["totalRows"] = totalRows;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class Job {
   /** [Required] Describes the job configuration. */
   JobConfiguration configuration;
 
   /** [Output-only] A hash of this resource. */
   core.String etag;
 
   /** [Output-only] Opaque ID field of the job */
   core.String id;
 
@@ skipping 81 matching lines @@
       _json["status"] = (status).toJson();
     }
     if (userEmail != null) {
       _json["user_email"] = userEmail;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class JobConfiguration {
   /** [Pick one] Copies a table. */
   JobConfigurationTableCopy copy;
 
   /**
    * [Optional] If set, don't actually run this job. A valid query will return a
    * mostly empty response with some processing statistics, while an invalid
    * query will return the same error it would if it wasn't a dry run. Behavior
    * of non-query jobs is undefined.
    */
@@ skipping 53 matching lines @@
       _json["load"] = (load).toJson();
     }
     if (query != null) {
       _json["query"] = (query).toJson();
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class JobConfigurationExtract {
   /**
    * [Optional] The compression type to use for exported files. Possible values
    * include GZIP and NONE. The default value is NONE.
    */
   core.String compression;
 
   /**
    * [Optional] The exported file format. Possible values include CSV,
    * NEWLINE_DELIMITED_JSON and AVRO. The default value is CSV. Tables with
@@ skipping 77 matching lines @@
       _json["printHeader"] = printHeader;
     }
     if (sourceTable != null) {
       _json["sourceTable"] = (sourceTable).toJson();
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class JobConfigurationLink {
   /**
    * [Optional] Specifies whether the job is allowed to create new tables. The
    * following values are supported: CREATE_IF_NEEDED: If the table does not
    * exist, BigQuery creates the table. CREATE_NEVER: The table must already
    * exist. If it does not, a 'notFound' error is returned in the job result.
    * The default value is CREATE_IF_NEEDED. Creation, truncation and append
    * actions occur as one atomic update upon job completion.
    */
   core.String createDisposition;
@@ skipping 47 matching lines @@
       _json["sourceUri"] = sourceUri;
     }
     if (writeDisposition != null) {
       _json["writeDisposition"] = writeDisposition;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class JobConfigurationLoad {
   /**
    * [Optional] Accept rows that are missing trailing optional columns. The
-   * missing values are treated as nulls. Default is false which treats short
-   * rows as errors. Only applicable to CSV, ignored for other formats.
+   * missing values are treated as nulls. If false, records with missing
+   * trailing columns are treated as bad records, and if there are too many bad
+   * records, an invalid error is returned in the job result. The default value
+   * is false. Only applicable to CSV, ignored for other formats.
    */
   core.bool allowJaggedRows;
 
   /**
    * Indicates if BigQuery should allow quoted data sections that contain
    * newline characters in a CSV file. The default value is false.
    */
   core.bool allowQuotedNewlines;
 
   /**
@@ skipping 20 matching lines @@
   /**
    * [Optional] The separator for fields in a CSV file. BigQuery converts the
    * string to ISO-8859-1 encoding, and then uses the first byte of the encoded
    * string to split the data in its raw, binary state. BigQuery also supports
    * the escape sequence "\t" to specify a tab separator. The default value is a
    * comma (',').
    */
   core.String fieldDelimiter;
 
   /**
-   * [Optional] Accept rows that contain values that do not match the schema.
-   * The unknown values are ignored. Default is false which treats unknown
-   * values as errors. For CSV this ignores extra values at the end of a line.
-   * For JSON this ignores named values that do not match any column name.
+   * [Optional] Indicates if BigQuery should allow extra values that are not
+   * represented in the table schema. If true, the extra values are ignored. If
+   * false, records with extra columns are treated as bad records, and if there
+   * are too many bad records, an invalid error is returned in the job result.
+   * The default value is false. The sourceFormat property determines what
+   * BigQuery treats as an extra value: CSV: Trailing columns JSON: Named values
+   * that don't match any column names
    */
   core.bool ignoreUnknownValues;
 
   /**
    * [Optional] The maximum number of bad records that BigQuery can ignore when
    * running the job. If the number of bad records exceeds this value, an
-   * 'invalid' error is returned in the job result and the job fails. The
-   * default value is 0, which requires that all records are valid.
+   * invalid error is returned in the job result. The default value is 0, which
+   * requires that all records are valid.
    */
   core.int maxBadRecords;
 
   /**
    * [Experimental] Names(case-sensitive) of properties to keep when importing
    * data. If this is populated, only the specified properties will be imported
    * for each entity. Currently, this is only supported for DATASTORE_BACKUP
    * imports and only top level properties are supported. If any specified
    * property is not found in the Datastore 'Kind' being imported, that is an
    * error. Note: This feature is experimental and can change in the future.
@@ skipping 37 matching lines @@
 
   /**
    * [Optional] The format of the data files. For CSV files, specify "CSV". For
    * datastore backups, specify "DATASTORE_BACKUP". For newline-delimited JSON,
    * specify "NEWLINE_DELIMITED_JSON". The default value is CSV.
    */
   core.String sourceFormat;
 
   /**
    * [Required] The fully-qualified URIs that point to your data in Google Cloud
-   * Storage. Wildcard names are only supported when they appear at the end of
-   * the URI.
+   * Storage. Each URI can contain one '*' wildcard character and it must come
+   * after the 'bucket' name.
    */
   core.List<core.String> sourceUris;
 
   /**
    * [Optional] Specifies the action that occurs if the destination table
    * already exists. The following values are supported: WRITE_TRUNCATE: If the
    * table already exists, BigQuery overwrites the table data. WRITE_APPEND: If
    * the table already exists, BigQuery appends the data to the table.
    * WRITE_EMPTY: If the table already exists and contains data, a 'duplicate'
    * error is returned in the job result. The default value is WRITE_EMPTY. Each
@@ skipping 111 matching lines @@
       _json["sourceUris"] = sourceUris;
     }
     if (writeDisposition != null) {
       _json["writeDisposition"] = writeDisposition;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class JobConfigurationQuery {
   /**
    * If true, allows the query to produce arbitrarily large result tables at a
    * slight cost in performance. Requires destinationTable to be set.
    */
   core.bool allowLargeResults;
 
   /**
    * [Optional] Specifies whether the job is allowed to create new tables. The
    * following values are supported: CREATE_IF_NEEDED: If the table does not
@@ skipping 29 matching lines @@
   /**
    * [Optional] Specifies a priority for the query. Possible values include
    * INTERACTIVE and BATCH. The default value is INTERACTIVE.
    */
   core.String priority;
 
   /** [Required] BigQuery SQL query to execute. */
   core.String query;
 
   /**
+   * [Experimental] If querying an external data source outside of BigQuery,
+   * describes the data format, location and other properties of the data
+   * source. By defining these properties, the data source can then be queried
+   * as if it were a standard BigQuery table.
+   */
+  core.Map<core.String, ExternalDataConfiguration> tableDefinitions;
+
+  /**
    * [Optional] Whether to look for the result in the query cache. The query
    * cache is a best-effort cache that will be flushed whenever tables in the
    * query are modified. Moreover, the query cache is only available when a
    * query does not have a destination table specified.
    */
   core.bool useQueryCache;
 
   /**
    * [Optional] Specifies the action that occurs if the destination table
    * already exists. The following values are supported: WRITE_TRUNCATE: If the
@@ skipping 28 matching lines @@
     }
     if (_json.containsKey("preserveNulls")) {
       preserveNulls = _json["preserveNulls"];
     }
     if (_json.containsKey("priority")) {
       priority = _json["priority"];
     }
     if (_json.containsKey("query")) {
       query = _json["query"];
     }
+    if (_json.containsKey("tableDefinitions")) {
+      tableDefinitions = commons.mapMap(_json["tableDefinitions"], (item) => new ExternalDataConfiguration.fromJson(item));
+    }
     if (_json.containsKey("useQueryCache")) {
       useQueryCache = _json["useQueryCache"];
     }
     if (_json.containsKey("writeDisposition")) {
       writeDisposition = _json["writeDisposition"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
@@ skipping 14 matching lines @@
     }
     if (preserveNulls != null) {
       _json["preserveNulls"] = preserveNulls;
     }
     if (priority != null) {
       _json["priority"] = priority;
     }
     if (query != null) {
       _json["query"] = query;
     }
+    if (tableDefinitions != null) {
+      _json["tableDefinitions"] = commons.mapMap(tableDefinitions, (item) => (item).toJson());
+    }
     if (useQueryCache != null) {
       _json["useQueryCache"] = useQueryCache;
     }
     if (writeDisposition != null) {
       _json["writeDisposition"] = writeDisposition;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class JobConfigurationTableCopy {
   /**
    * [Optional] Specifies whether the job is allowed to create new tables. The
    * following values are supported: CREATE_IF_NEEDED: If the table does not
    * exist, BigQuery creates the table. CREATE_NEVER: The table must already
    * exist. If it does not, a 'notFound' error is returned in the job result.
    * The default value is CREATE_IF_NEEDED. Creation, truncation and append
    * actions occur as one atomic update upon job completion.
    */
   core.String createDisposition;
@@ skipping 56 matching lines @@
       _json["sourceTables"] = sourceTables.map((value) => (value).toJson()).toList();
     }
     if (writeDisposition != null) {
       _json["writeDisposition"] = writeDisposition;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class JobListJobs {
   /** [Full-projection-only] Specifies the job configuration. */
   JobConfiguration configuration;
 
   /** A result object that will be present only if the job has failed. */
   ErrorProto errorResult;
 
   /** Unique opaque ID of the job. */
   core.String id;
 
@@ skipping 81 matching lines @@
       _json["status"] = (status).toJson();
     }
     if (userEmail != null) {
       _json["user_email"] = userEmail;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class JobList {
   /** A hash of this page of results. */
   core.String etag;
 
   /** List of jobs that were requested. */
   core.List<JobListJobs> jobs;
 
   /** The resource type of the response. */
   core.String kind;
 
@@ skipping 39 matching lines @@
       _json["nextPageToken"] = nextPageToken;
     }
     if (totalItems != null) {
       _json["totalItems"] = totalItems;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class JobReference {
   /**
    * [Required] The ID of the job. The ID must contain only letters (a-z, A-Z),
    * numbers (0-9), underscores (_), or dashes (-). The maximum length is 1,024
    * characters.
    */
   core.String jobId;
 
   /** [Required] The ID of the project containing this job. */
   core.String projectId;
@@ skipping 16 matching lines @@
       _json["jobId"] = jobId;
     }
     if (projectId != null) {
       _json["projectId"] = projectId;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class JobStatistics {
   /**
    * [Output-only] Creation time of this job, in milliseconds since the epoch.
    * This field will be present on all jobs.
    */
   core.String creationTime;
 
   /**
    * [Output-only] End time of this job, in milliseconds since the epoch. This
    * field will be present whenever a job is in the DONE state.
@@ skipping 70 matching lines @@
       _json["startTime"] = startTime;
     }
     if (totalBytesProcessed != null) {
       _json["totalBytesProcessed"] = totalBytesProcessed;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class JobStatistics2 {
   /**
    * [Output-only] Whether the query result was fetched from the query cache.
    */
   core.bool cacheHit;
 
   /** [Output-only] Total bytes processed for this job. */
   core.String totalBytesProcessed;
 
 
@@ skipping 14 matching lines @@
       _json["cacheHit"] = cacheHit;
     }
     if (totalBytesProcessed != null) {
       _json["totalBytesProcessed"] = totalBytesProcessed;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class JobStatistics3 {
   /** [Output-only] Number of bytes of source data in a joad job. */
   core.String inputFileBytes;
 
   /** [Output-only] Number of source files in a load job. */
   core.String inputFiles;
 
   /**
    * [Output-only] Size of the loaded data in bytes. Note that while an import
    * job is in the running state, this value may change.
@@ skipping 36 matching lines @@
       _json["outputBytes"] = outputBytes;
     }
     if (outputRows != null) {
       _json["outputRows"] = outputRows;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class JobStatistics4 {
   /**
    * [Experimental] Number of files per destination URI or URI pattern specified
    * in the extract configuration. These values will be in the same order as the
    * URIs specified in the 'destinationUris' field.
    */
   core.List<core.String> destinationUriFileCounts;
 
 
   JobStatistics4();
 
   JobStatistics4.fromJson(core.Map _json) {
     if (_json.containsKey("destinationUriFileCounts")) {
       destinationUriFileCounts = _json["destinationUriFileCounts"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (destinationUriFileCounts != null) {
       _json["destinationUriFileCounts"] = destinationUriFileCounts;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class JobStatus {
   /**
    * [Output-only] Final error result of the job. If present, indicates that the
    * job has completed and was unsuccessful.
    */
   ErrorProto errorResult;
 
   /**
    * [Output-only] All errors encountered during the running of the job. Errors
    * here do not necessarily mean that the job has completed or was
@@ skipping 66 matching lines @@
   void clear() {
     _innerMap.clear();
   }
 
   core.Iterable<core.String> get keys => _innerMap.keys;
 
   core.Object remove(core.Object key) => _innerMap.remove(key);
 }
 
 
-/** Not documented yet. */
 class ProjectListProjects {
   /** A descriptive name for this project. */
   core.String friendlyName;
 
   /** An opaque ID of this project. */
   core.String id;
 
   /** The resource type. */
   core.String kind;
 
@@ skipping 39 matching lines @@
       _json["numericId"] = numericId;
     }
     if (projectReference != null) {
       _json["projectReference"] = (projectReference).toJson();
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class ProjectList {
   /** A hash of the page of results */
   core.String etag;
 
   /** The type of list. */
   core.String kind;
 
   /** A token to request the next page of results. */
   core.String nextPageToken;
 
@@ skipping 39 matching lines @@
       _json["projects"] = projects.map((value) => (value).toJson()).toList();
     }
     if (totalItems != null) {
       _json["totalItems"] = totalItems;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class ProjectReference {
   /**
    * [Required] ID of the project. Can be either the numeric ID or the assigned
    * ID of the project.
    */
   core.String projectId;
 
 
   ProjectReference();
 
   ProjectReference.fromJson(core.Map _json) {
     if (_json.containsKey("projectId")) {
       projectId = _json["projectId"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (projectId != null) {
       _json["projectId"] = projectId;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class QueryRequest {
   /**
    * [Optional] Specifies the default datasetId and projectId to assume for any
    * unqualified table names in the query. If not set, all table names in the
    * query string must be qualified in the format 'datasetId.tableId'.
    */
   DatasetReference defaultDataset;
 
   /**
    * [Optional] If set, don't actually run this job. A valid query will return a
@@ skipping 96 matching lines @@
       _json["timeoutMs"] = timeoutMs;
     }
     if (useQueryCache != null) {
       _json["useQueryCache"] = useQueryCache;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class QueryResponse {
   /** Whether the query result was fetched from the query cache. */
   core.bool cacheHit;
 
   /**
    * Whether the query has completed or not. If rows or totalRows are present,
    * this will always be true. If this is false, totalRows will not be
    * available.
    */
   core.bool jobComplete;
@@ skipping 99 matching lines @@
       _json["totalBytesProcessed"] = totalBytesProcessed;
     }
     if (totalRows != null) {
       _json["totalRows"] = totalRows;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class Table {
   /**
    * [Output-only] The time when this table was created, in milliseconds since
    * the epoch.
    */
   core.String creationTime;
 
   /** [Optional] A user-friendly description of this table. */
   core.String description;
 
@@ skipping 156 matching lines @@
 }
 
 
 /**
  * Represents a single cell in the result set. Users of the java client can
  * detect whether their value result is null by calling
  * 'com.google.api.client.util.Data.isNull(cell.getV())'.
  */
 class TableCell {
   /**
-   * Not documented yet.
+   *
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.Object v;
 
 
   TableCell();
 
   TableCell.fromJson(core.Map _json) {
     if (_json.containsKey("v")) {
       v = _json["v"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (v != null) {
       _json["v"] = v;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class TableDataInsertAllRequestRows {
   /**
    * [Optional] A unique ID for each row. BigQuery uses this property to detect
    * duplicate insertion requests on a best-effort basis.
    */
   core.String insertId;
 
   /**
    * [Required] A JSON object that contains a row of data. The object's
    * properties and values must match the destination table's schema.
@@ skipping 18 matching lines @@
       _json["insertId"] = insertId;
     }
     if (json != null) {
       _json["json"] = json;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class TableDataInsertAllRequest {
+  /**
+   * [Optional] Accept rows that contain values that do not match the schema.
+   * The unknown values are ignored. Default is false, which treats unknown
+   * values as errors.
+   */
+  core.bool ignoreUnknownValues;
+
   /** The resource type of the response. */
   core.String kind;
 
   /** The rows to insert. */
   core.List<TableDataInsertAllRequestRows> rows;
 
+  /**
+   * [Optional] Insert all valid rows of a request, even if invalid rows exist.
+   * The default value is false, which causes the entire request to fail if any
+   * invalid rows exist.
+   */
+  core.bool skipInvalidRows;
+
 
   TableDataInsertAllRequest();
 
   TableDataInsertAllRequest.fromJson(core.Map _json) {
+    if (_json.containsKey("ignoreUnknownValues")) {
+      ignoreUnknownValues = _json["ignoreUnknownValues"];
+    }
     if (_json.containsKey("kind")) {
       kind = _json["kind"];
     }
     if (_json.containsKey("rows")) {
       rows = _json["rows"].map((value) => new TableDataInsertAllRequestRows.fromJson(value)).toList();
     }
+    if (_json.containsKey("skipInvalidRows")) {
+      skipInvalidRows = _json["skipInvalidRows"];
+    }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
+    if (ignoreUnknownValues != null) {
+      _json["ignoreUnknownValues"] = ignoreUnknownValues;
+    }
     if (kind != null) {
       _json["kind"] = kind;
     }
     if (rows != null) {
       _json["rows"] = rows.map((value) => (value).toJson()).toList();
     }
+    if (skipInvalidRows != null) {
+      _json["skipInvalidRows"] = skipInvalidRows;
+    }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class TableDataInsertAllResponseInsertErrors {
   /** Error information for the row indicated by the index property. */
   core.List<ErrorProto> errors;
 
   /** The index of the row that error applies to. */
   core.int index;
 
 
   TableDataInsertAllResponseInsertErrors();
 
@@ skipping 12 matching lines @@
       _json["errors"] = errors.map((value) => (value).toJson()).toList();
     }
     if (index != null) {
       _json["index"] = index;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class TableDataInsertAllResponse {
   /** An array of errors for rows that were not inserted. */
   core.List<TableDataInsertAllResponseInsertErrors> insertErrors;
 
   /** The resource type of the response. */
   core.String kind;
 
 
   TableDataInsertAllResponse();
 
@@ skipping 12 matching lines @@
       _json["insertErrors"] = insertErrors.map((value) => (value).toJson()).toList();
     }
     if (kind != null) {
       _json["kind"] = kind;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class TableDataList {
   /** A hash of this page of results. */
   core.String etag;
 
   /** The resource type of the response. */
   core.String kind;
 
   /**
    * A token used for paging results. Providing this token instead of the
    * startIndex parameter can help you retrieve stable results when an
@@ skipping 43 matching lines @@
       _json["rows"] = rows.map((value) => (value).toJson()).toList();
     }
     if (totalRows != null) {
       _json["totalRows"] = totalRows;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class TableFieldSchema {
   /**
    * [Optional] The field description. The maximum length is 16K characters.
    */
   core.String description;
 
   /**
    * [Optional] Describes the nested schema fields if the type property is set
    * to RECORD.
    */
@@ skipping 55 matching lines @@
       _json["name"] = name;
     }
     if (type != null) {
       _json["type"] = type;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class TableListTables {
   /** The user-friendly name for this table. */
   core.String friendlyName;
 
   /** An opaque ID of the table */
   core.String id;
 
   /** The resource type. */
   core.String kind;
 
@@ skipping 39 matching lines @@
       _json["tableReference"] = (tableReference).toJson();
     }
     if (type != null) {
       _json["type"] = type;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class TableList {
   /** A hash of this page of results. */
   core.String etag;
 
   /** The type of list. */
   core.String kind;
 
   /** A token to request the next page of results. */
   core.String nextPageToken;
 
@@ skipping 39 matching lines @@
       _json["tables"] = tables.map((value) => (value).toJson()).toList();
     }
     if (totalItems != null) {
       _json["totalItems"] = totalItems;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class TableReference {
   /** [Required] The ID of the dataset containing this table. */
   core.String datasetId;
 
   /** [Required] The ID of the project containing this table. */
   core.String projectId;
 
   /**
    * [Required] The ID of the table. The ID must contain only letters (a-z,
    * A-Z), numbers (0-9), or underscores (_). The maximum length is 1,024
@@ skipping 29 matching lines @@
     }
     return _json;
   }
 }
 
 
 /**
  * Represents a single row in the result set, consisting of one or more fields.
  */
 class TableRow {
-  /** Not documented yet. */
   core.List<TableCell> f;
 
 
   TableRow();
 
   TableRow.fromJson(core.Map _json) {
     if (_json.containsKey("f")) {
       f = _json["f"].map((value) => new TableCell.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (f != null) {
       _json["f"] = f.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class TableSchema {
   /** Describes the fields in a table. */
   core.List<TableFieldSchema> fields;
 
 
   TableSchema();
 
   TableSchema.fromJson(core.Map _json) {
     if (_json.containsKey("fields")) {
       fields = _json["fields"].map((value) => new TableFieldSchema.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (fields != null) {
       _json["fields"] = fields.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class ViewDefinition {
   /** [Required] A query that BigQuery executes when the view is referenced. */
   core.String query;
 
 
   ViewDefinition();
 
   ViewDefinition.fromJson(core.Map _json) {
     if (_json.containsKey("query")) {
       query = _json["query"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (query != null) {
       _json["query"] = query;
     }
     return _json;
   }
 }
-
-