Api-roll 45: 2017-02-13

generated/googleapis_beta/lib/ml/v1beta1.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis_beta.ml.v1beta1;
 
 import 'dart:core' as core;
 import 'dart:async' as async;
 import 'dart:convert' as convert;
 
 import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
 import 'package:http/http.dart' as http;
@@ skipping 69 matching lines @@
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new GoogleCloudMlV1beta1GetConfigResponse.fromJson(data));
   }
 
   /**
    * Performs prediction on the data in the request.
    *
-   * Responses are very similar to requests. There are two top-level fields,
-   * each of which are JSON lists:
-   *
-   * <dl>
-   *   <dt>predictions</dt>
-   *   <dd>The list of predictions, one per instance in the request.</dd>
-   *   <dt>error</dt>
-   *   <dd>An error message returned instead of a prediction list if any
-   *       instance produced an error.</dd>
-   * </dl>
-   *
-   * If the call is successful, the response body will contain one prediction
-   * entry per instance in the request body. If prediction fails for any
-   * instance, the response body will contain no predictions and will contian
-   * a single error entry instead.
-   *
-   * Even though there is one prediction per instance, the format of a
-   * prediction is not directly related to the format of an instance.
-   * Predictions take whatever format is specified in the outputs collection
-   * defined in the model. The collection of predictions is returned in a JSON
-   * list. Each member of the list can be a simple value, a list, or a JSON
-   * object of any complexity. If your model has more than one output tensor,
-   * each prediction will be a JSON object containing a name/value pair for each
-   * output. The names identify the output aliases in the graph.
-   *
-   * The following examples show some possible responses:
-   *
-   * A simple set of predictions for three input instances, where each
-   * prediction is an integer value:
-   * <pre>
-   * {"predictions": [5, 4, 3]}
-   * </pre>
-   * A more complex set of predictions, each containing two named values that
-   * correspond to output tensors, named **label** and **scores** respectively.
-   * The value of **label** is the predicted category ("car" or "beach") and
-   * **scores** contains a list of probabilities for that instance across the
-   * possible categories.
-   * <pre>
-   * {"predictions": [{"label": "beach", "scores": [0.1, 0.9]},
-   *                  {"label": "car", "scores": [0.75, 0.25]}]}
-   * </pre>
-   * A response when there is an error processing an input instance:
-   * <pre>
-   * {"error": "Divide by zero"}
-   * </pre>
+   * **** REMOVE FROM GENERATED DOCUMENTATION
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [name] - Required. The resource name of a model or a version.
    *
    * Authorization: requires `Viewer` role on the parent project.
    * Value must have pattern "^projects/.+$".
    *
@@ skipping 180 matching lines @@
   /**
    * Lists the jobs in the project.
    *
    * Request parameters:
    *
    * [parent] - Required. The name of the project for which to list jobs.
    *
    * Authorization: requires `Viewer` role on the specified project.
    * Value must have pattern "^projects/[^/]+$".
    *
-   * [pageSize] - Optional. The number of jobs to retrieve per "page" of
-   * results. If there
-   * are more remaining results than this number, the response message will
-   * contain a valid value in the `next_page_token` field.
-   *
-   * The default value is 20, and the maximum page size is 100.
-   *
    * [filter] - Optional. Specifies the subset of jobs to retrieve.
    *
    * [pageToken] - Optional. A page token to request the next page of results.
    *
    * You get the token from the `next_page_token` field of the response from
    * the previous call.
    *
+   * [pageSize] - Optional. The number of jobs to retrieve per "page" of
+   * results. If there
+   * are more remaining results than this number, the response message will
+   * contain a valid value in the `next_page_token` field.
+   *
+   * The default value is 20, and the maximum page size is 100.
+   *
    * Completes with a [GoogleCloudMlV1beta1ListJobsResponse].
    *
    * 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<GoogleCloudMlV1beta1ListJobsResponse> list(core.String parent, {core.int pageSize, core.String filter, core.String pageToken}) {
+  async.Future<GoogleCloudMlV1beta1ListJobsResponse> list(core.String parent, {core.String filter, core.String pageToken, core.int pageSize}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (parent == null) {
       throw new core.ArgumentError("Parameter parent is required.");
     }
-    if (pageSize != null) {
-      _queryParams["pageSize"] = ["${pageSize}"];
-    }
     if (filter != null) {
       _queryParams["filter"] = [filter];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
+    if (pageSize != null) {
+      _queryParams["pageSize"] = ["${pageSize}"];
+    }
 
     _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$parent') + '/jobs';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 158 matching lines @@
    * Each project can contain multiple models, and each model can have multiple
    * versions.
    *
    * Request parameters:
    *
    * [parent] - Required. The name of the project whose models are to be listed.
    *
    * Authorization: requires `Viewer` role on the specified project.
    * Value must have pattern "^projects/[^/]+$".
    *
+   * [pageToken] - Optional. A page token to request the next page of results.
+   *
+   * You get the token from the `next_page_token` field of the response from
+   * the previous call.
+   *
    * [pageSize] - Optional. The number of models to retrieve per "page" of
    * results. If there
    * are more remaining results than this number, the response message will
    * contain a valid value in the `next_page_token` field.
    *
    * The default value is 20, and the maximum page size is 100.
    *
-   * [pageToken] - Optional. A page token to request the next page of results.
-   *
-   * You get the token from the `next_page_token` field of the response from
-   * the previous call.
-   *
    * Completes with a [GoogleCloudMlV1beta1ListModelsResponse].
    *
    * 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<GoogleCloudMlV1beta1ListModelsResponse> list(core.String parent, {core.int pageSize, core.String pageToken}) {
+  async.Future<GoogleCloudMlV1beta1ListModelsResponse> list(core.String parent, {core.String pageToken, core.int pageSize}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (parent == null) {
       throw new core.ArgumentError("Parameter parent is required.");
     }
+    if (pageToken != null) {
+      _queryParams["pageToken"] = [pageToken];
+    }
     if (pageSize != null) {
       _queryParams["pageSize"] = ["${pageSize}"];
     }
-    if (pageToken != null) {
-      _queryParams["pageToken"] = [pageToken];
-    }
 
     _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$parent') + '/models';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 168 matching lines @@
    * only a limited number of results at a time, you can request that the list
    * be retrieved in batches (called pages):
    *
    * Request parameters:
    *
    * [parent] - Required. The name of the model for which to list the version.
    *
    * Authorization: requires `Viewer` role on the parent project.
    * Value must have pattern "^projects/[^/]+/models/[^/]+$".
    *
+   * [pageToken] - Optional. A page token to request the next page of results.
+   *
+   * You get the token from the `next_page_token` field of the response from
+   * the previous call.
+   *
    * [pageSize] - Optional. The number of versions to retrieve per "page" of
    * results. If
    * there are more remaining results than this number, the response message
    * will contain a valid value in the `next_page_token` field.
    *
    * The default value is 20, and the maximum page size is 100.
    *
-   * [pageToken] - Optional. A page token to request the next page of results.
-   *
-   * You get the token from the `next_page_token` field of the response from
-   * the previous call.
-   *
    * Completes with a [GoogleCloudMlV1beta1ListVersionsResponse].
    *
    * 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<GoogleCloudMlV1beta1ListVersionsResponse> list(core.String parent, {core.int pageSize, core.String pageToken}) {
+  async.Future<GoogleCloudMlV1beta1ListVersionsResponse> list(core.String parent, {core.String pageToken, core.int pageSize}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (parent == null) {
       throw new core.ArgumentError("Parameter parent is required.");
     }
+    if (pageToken != null) {
+      _queryParams["pageToken"] = [pageToken];
+    }
     if (pageSize != null) {
       _queryParams["pageSize"] = ["${pageSize}"];
     }
-    if (pageToken != null) {
-      _queryParams["pageToken"] = [pageToken];
-    }
 
     _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$parent') + '/versions';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 205 matching lines @@
    * server doesn't support this method, it returns `UNIMPLEMENTED`.
    *
    * NOTE: the `name` binding below allows API services to override the binding
    * to use different resource name schemes, such as `users / * /operations`.
    *
    * Request parameters:
    *
    * [name] - The name of the operation collection.
    * Value must have pattern "^projects/[^/]+$".
    *
-   * [pageSize] - The standard list page size.
-   *
    * [filter] - The standard list filter.
    *
    * [pageToken] - The standard list page token.
    *
+   * [pageSize] - The standard list page size.
+   *
    * Completes with a [GoogleLongrunningListOperationsResponse].
    *
    * 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<GoogleLongrunningListOperationsResponse> list(core.String name, {core.int pageSize, core.String filter, core.String pageToken}) {
+  async.Future<GoogleLongrunningListOperationsResponse> list(core.String name, {core.String filter, core.String pageToken, core.int pageSize}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
-    if (pageSize != null) {
-      _queryParams["pageSize"] = ["${pageSize}"];
-    }
     if (filter != null) {
       _queryParams["filter"] = [filter];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
+    if (pageSize != null) {
+      _queryParams["pageSize"] = ["${pageSize}"];
+    }
 
     _url = 'v1beta1/' + commons.Escaper.ecapeVariableReserved('$name') + '/operations';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 75 matching lines @@
     if (contentType != null) {
       _json["contentType"] = contentType;
     }
     if (data != null) {
       _json["data"] = data;
     }
     return _json;
   }
 }
 
+/** Represents the metadata of the long-running operation. */
+class GoogleCloudMlV1OperationMetadata {
+  /** The time the operation was submitted. */
+  core.String createTime;
+  /** The time operation processing completed. */
+  core.String endTime;
+  /** Indicates whether a request to cancel this operation has been made. */
+  core.bool isCancellationRequested;
+  /** Contains the name of the model associated with the operation. */
+  core.String modelName;
+  /**
+   * The operation type.
+   * Possible string values are:
+   * - "OPERATION_TYPE_UNSPECIFIED" : Unspecified operation type.
+   * - "CREATE_VERSION" : An operation to create a new version.
+   * - "DELETE_VERSION" : An operation to delete an existing version.
+   * - "DELETE_MODEL" : An operation to delete an existing model.
+   */
+  core.String operationType;
+  /** The time operation processing started. */
+  core.String startTime;
+  /** Contains the version associated with the operation. */
+  GoogleCloudMlV1Version version;
+
+  GoogleCloudMlV1OperationMetadata();
+
+  GoogleCloudMlV1OperationMetadata.fromJson(core.Map _json) {
+    if (_json.containsKey("createTime")) {
+      createTime = _json["createTime"];
+    }
+    if (_json.containsKey("endTime")) {
+      endTime = _json["endTime"];
+    }
+    if (_json.containsKey("isCancellationRequested")) {
+      isCancellationRequested = _json["isCancellationRequested"];
+    }
+    if (_json.containsKey("modelName")) {
+      modelName = _json["modelName"];
+    }
+    if (_json.containsKey("operationType")) {
+      operationType = _json["operationType"];
+    }
+    if (_json.containsKey("startTime")) {
+      startTime = _json["startTime"];
+    }
+    if (_json.containsKey("version")) {
+      version = new GoogleCloudMlV1Version.fromJson(_json["version"]);
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (createTime != null) {
+      _json["createTime"] = createTime;
+    }
+    if (endTime != null) {
+      _json["endTime"] = endTime;
+    }
+    if (isCancellationRequested != null) {
+      _json["isCancellationRequested"] = isCancellationRequested;
+    }
+    if (modelName != null) {
+      _json["modelName"] = modelName;
+    }
+    if (operationType != null) {
+      _json["operationType"] = operationType;
+    }
+    if (startTime != null) {
+      _json["startTime"] = startTime;
+    }
+    if (version != null) {
+      _json["version"] = (version).toJson();
+    }
+    return _json;
+  }
+}
+
+/**
+ * Represents a version of the model.
+ *
+ * Each version is a trained model deployed in the cloud, ready to handle
+ * prediction requests. A model can have multiple versions. You can get
+ * information about all of the versions of a given model by calling
+ * [projects.models.versions.list](/ml/reference/rest/v1/projects.models.versions/list).
+ */
+class GoogleCloudMlV1Version {
+  /** Output only. The time the version was created. */
+  core.String createTime;
+  /**
+   * Required. The Google Cloud Storage location of the trained model used to
+   * create the version. See the
+   * [overview of model deployment](/ml/docs/concepts/deployment-overview) for
+   * more informaiton.
+   *
+   * When passing Version to
+   * [projects.models.versions.create](/ml/reference/rest/v1/projects.models.versions/create)
+   * the model service uses the specified location as the source of the model.
+   * Once deployed, the model version is hosted by the prediction service, so
+   * this location is useful only as a historical record.
+   */
+  core.String deploymentUri;
+  /**
+   * Optional. The description specified for the version when it was created.
+   */
+  core.String description;
+  /**
+   * Output only. If true, this version will be used to handle prediction
+   * requests that do not specify a version.
+   *
+   * You can change the default version by calling
+   * [projects.methods.versions.setDefault](/ml/reference/rest/v1/projects.models.versions/setDefault).
+   */
+  core.bool isDefault;
+  /** Output only. The time the version was last used for prediction. */
+  core.String lastUseTime;
+  /**
+   * Required.The name specified for the version when it was created.
+   *
+   * The version name must be unique within the model it is created in.
+   */
+  core.String name;
+  /**
+   * Optional. The Google Cloud ML runtime version to use for this deployment.
+   * If not set, Google Cloud ML will choose a version.
+   */
+  core.String runtimeVersion;
+
+  GoogleCloudMlV1Version();
+
+  GoogleCloudMlV1Version.fromJson(core.Map _json) {
+    if (_json.containsKey("createTime")) {
+      createTime = _json["createTime"];
+    }
+    if (_json.containsKey("deploymentUri")) {
+      deploymentUri = _json["deploymentUri"];
+    }
+    if (_json.containsKey("description")) {
+      description = _json["description"];
+    }
+    if (_json.containsKey("isDefault")) {
+      isDefault = _json["isDefault"];
+    }
+    if (_json.containsKey("lastUseTime")) {
+      lastUseTime = _json["lastUseTime"];
+    }
+    if (_json.containsKey("name")) {
+      name = _json["name"];
+    }
+    if (_json.containsKey("runtimeVersion")) {
+      runtimeVersion = _json["runtimeVersion"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (createTime != null) {
+      _json["createTime"] = createTime;
+    }
+    if (deploymentUri != null) {
+      _json["deploymentUri"] = deploymentUri;
+    }
+    if (description != null) {
+      _json["description"] = description;
+    }
+    if (isDefault != null) {
+      _json["isDefault"] = isDefault;
+    }
+    if (lastUseTime != null) {
+      _json["lastUseTime"] = lastUseTime;
+    }
+    if (name != null) {
+      _json["name"] = name;
+    }
+    if (runtimeVersion != null) {
+      _json["runtimeVersion"] = runtimeVersion;
+    }
+    return _json;
+  }
+}
+
 /** An observed value of a metric. */
 class GoogleCloudMlV1beta1HyperparameterOutputHyperparameterMetric {
   /** The objective value at this training step. */
   core.double objectiveValue;
   /** The global training step for this metric. */
   core.String trainingStep;
 
   GoogleCloudMlV1beta1HyperparameterOutputHyperparameterMetric();
 
   GoogleCloudMlV1beta1HyperparameterOutputHyperparameterMetric.fromJson(core.Map _json) {
@@ skipping 119 matching lines @@
    * `MAXIMIZE` and `MINIMIZE`.
    *
    * Defaults to `MAXIMIZE`.
    * Possible string values are:
    * - "GOAL_TYPE_UNSPECIFIED" : Goal Type will default to maximize.
    * - "MAXIMIZE" : Maximize the goal metric.
    * - "MINIMIZE" : Minimize the goal metric.
    */
   core.String goal;
   /**
+   * Optional. The Tensorflow summary tag name to use for optimizing trials. For
+   * current versions of Tensorflow, this tag name should exactly match what is
+   * shown in Tensorboard, including all scopes.  For versions of Tensorflow
+   * prior to 0.12, this should be only the tag passed to tf.Summary.
+   * By default, "training/hptuning/metric" will be used.
+   */
+  core.String hyperparameterMetricTag;
+  /**
    * Optional. The number of training trials to run concurrently.
    * You can reduce the time it takes to perform hyperparameter tuning by adding
    * trials in parallel. However, each trail only benefits from the information
    * gained in completed trials. That means that a trial does not get access to
    * the results of trials running at the same time, which could reduce the
    * quality of the overall optimization.
    *
    * Each trial will use the same scale tier and machine types.
    *
    * Defaults to one.
    */
   core.int maxParallelTrials;
   /**
    * Optional. How many training trials should be attempted to optimize
    * the specified hyperparameters.
    *
    * Defaults to one.
    */
   core.int maxTrials;
   /** Required. The set of parameters to tune. */
   core.List<GoogleCloudMlV1beta1ParameterSpec> params;
 
   GoogleCloudMlV1beta1HyperparameterSpec();
 
   GoogleCloudMlV1beta1HyperparameterSpec.fromJson(core.Map _json) {
     if (_json.containsKey("goal")) {
       goal = _json["goal"];
     }
+    if (_json.containsKey("hyperparameterMetricTag")) {
+      hyperparameterMetricTag = _json["hyperparameterMetricTag"];
+    }
     if (_json.containsKey("maxParallelTrials")) {
       maxParallelTrials = _json["maxParallelTrials"];
     }
     if (_json.containsKey("maxTrials")) {
       maxTrials = _json["maxTrials"];
     }
     if (_json.containsKey("params")) {
       params = _json["params"].map((value) => new GoogleCloudMlV1beta1ParameterSpec.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (goal != null) {
       _json["goal"] = goal;
     }
+    if (hyperparameterMetricTag != null) {
+      _json["hyperparameterMetricTag"] = hyperparameterMetricTag;
+    }
     if (maxParallelTrials != null) {
       _json["maxParallelTrials"] = maxParallelTrials;
     }
     if (maxTrials != null) {
       _json["maxTrials"] = maxTrials;
     }
     if (params != null) {
       _json["params"] = params.map((value) => (value).toJson()).toList();
     }
     return _json;
@@ skipping 226 matching lines @@
   GoogleCloudMlV1beta1Version defaultVersion;
   /** Optional. The description specified for the model when it was created. */
   core.String description;
   /**
    * Required. The name specified for the model when it was created.
    *
    * The model name must be unique within the project it is created in.
    */
   core.String name;
   /**
+   * Optional. If true, enables StackDriver Logging for online prediction.
+   * Default is false.
+   */
+  core.bool onlinePredictionLogging;
+  /**
    * Optional. The list of regions where the model is going to be deployed.
    * Currently only one region per model is supported.
    * Defaults to 'us-central1' if nothing is set.
    */
   core.List<core.String> regions;
 
   GoogleCloudMlV1beta1Model();
 
   GoogleCloudMlV1beta1Model.fromJson(core.Map _json) {
     if (_json.containsKey("defaultVersion")) {
       defaultVersion = new GoogleCloudMlV1beta1Version.fromJson(_json["defaultVersion"]);
     }
     if (_json.containsKey("description")) {
       description = _json["description"];
     }
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
+    if (_json.containsKey("onlinePredictionLogging")) {
+      onlinePredictionLogging = _json["onlinePredictionLogging"];
+    }
     if (_json.containsKey("regions")) {
       regions = _json["regions"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (defaultVersion != null) {
       _json["defaultVersion"] = (defaultVersion).toJson();
     }
     if (description != null) {
       _json["description"] = description;
     }
     if (name != null) {
       _json["name"] = name;
     }
+    if (onlinePredictionLogging != null) {
+      _json["onlinePredictionLogging"] = onlinePredictionLogging;
+    }
     if (regions != null) {
       _json["regions"] = regions;
     }
     return _json;
   }
 }
 
 /** Represents the metadata of the long-running operation. */
 class GoogleCloudMlV1beta1OperationMetadata {
   /** The time the operation was submitted. */
@@ skipping 198 matching lines @@
  * <dl>
  *   <dt>instances</dt>
  *   <dd>A JSON array containing values representing the instances to use for
  *       prediction.</dd>
  * </dl>
  *
  * The structure of each element of the instances list is determined by your
  * model's input definition. Instances can include named inputs or can contain
  * only unlabeled values.
  *
- * Most data does not include named inputs. Some instances will be simple
+ * Not all data includes named inputs. Some instances will be simple
  * JSON values (boolean, number, or string). However, instances are often lists
  * of simple values, or complex nested lists. Here are some examples of request
  * bodies:
  *
  * CSV data with each row encoded as a string value:
  * <pre>
  * {"instances": ["1.0,true,\\"x\\"", "-2.0,false,\\"y\\""]}
  * </pre>
  * Plain text:
  * <pre>
  * {"instances": ["the quick brown fox", "la bruja le dio"]}
  * </pre>
  * Sentences encoded as lists of words (vectors of strings):
  * <pre>
- * {"instances": [["the","quick","brown"], ["la","bruja","le"]]}
+ * {
+ *   "instances": [
+ *     ["the","quick","brown"],
+ *     ["la","bruja","le"],
+ *     ...
+ *   ]
+ * }
  * </pre>
  * Floating point scalar values:
  * <pre>
  * {"instances": [0.0, 1.1, 2.2]}
  * </pre>
  * Vectors of integers:
  * <pre>
- * {"instances": [[0, 1, 2], [3, 4, 5],...]}
+ * {
+ *   "instances": [
+ *     [0, 1, 2],
+ *     [3, 4, 5],
+ *     ...
+ *   ]
+ * }
  * </pre>
  * Tensors (in this case, two-dimensional tensors):
  * <pre>
- * {"instances": [[[0, 1, 2], [3, 4, 5]], ...]}
+ * {
+ *   "instances": [
+ *     [
+ *       [0, 1, 2],
+ *       [3, 4, 5]
+ *     ],
+ *     ...
+ *   ]
+ * }
  * </pre>
- * Images represented as a three-dimensional list. In this encoding scheme the
- * first two dimensions represent the rows and columns of the image, and the
- * third contains the R, G, and B values for each pixel.
+ * Images can be represented different ways. In this encoding scheme the first
+ * two dimensions represent the rows and columns of the image, and the third
+ * contains lists (vectors) of the R, G, and B values for each pixel.
  * <pre>
- * {"instances": [[[[138, 30, 66], [130, 20, 56], ...]]]]}
+ * {
+ *   "instances": [
+ *     [
+ *       [
+ *         [138, 30, 66],
+ *         [130, 20, 56],
+ *         ...
+ *       ],
+ *       [
+ *         [126, 38, 61],
+ *         [122, 24, 57],
+ *         ...
+ *       ],
+ *       ...
+ *     ],
+ *     ...
+ *   ]
+ * }
  * </pre>
- * Data must be encoded as UTF-8. If your data uses another character encoding,
- * you must base64 encode the data and mark it as binary. To mark a JSON string
- * as binary, replace it with an object with a single attribute named `b`:
- * <pre>{"b": "..."} </pre>
+ * JSON strings must be encoded as UTF-8. To send binary data, you must
+ * base64-encode the data and mark it as binary. To mark a JSON string
+ * as binary, replace it with a JSON object with a single attribute named `b64`:
+ * <pre>{"b64": "..."} </pre>
  * For example:
  *
  * Two Serialized tf.Examples (fake data, for illustrative purposes only):
  * <pre>
  * {"instances": [{"b64": "X5ad6u"}, {"b64": "IA9j4nx"}]}
  * </pre>
  * Two JPEG image byte strings (fake data, for illustrative purposes only):
  * <pre>
  * {"instances": [{"b64": "ASa8asdf"}, {"b64": "JLK7ljk3"}]}
  * </pre>
  * If your data includes named references, format each instance as a JSON object
  * with the named references as the keys:
  *
  * JSON input data to be preprocessed:
  * <pre>
- * {"instances": [{"a": 1.0,  "b": true,  "c": "x"},
- *                {"a": -2.0, "b": false, "c": "y"}]}
+ * {
+ *   "instances": [
+ *     {
+ *       "a": 1.0,
+ *       "b": true,
+ *       "c": "x"
+ *     },
+ *     {
+ *       "a": -2.0,
+ *       "b": false,
+ *       "c": "y"
+ *     }
+ *   ]
+ * }
  * </pre>
  * Some models have an underlying TensorFlow graph that accepts multiple input
  * tensors. In this case, you should use the names of JSON name/value pairs to
  * identify the input tensors, as shown in the following exmaples:
  *
  * For a graph with input tensor aliases "tag" (string) and "image"
  * (base64-encoded string):
  * <pre>
- * {"instances": [{"tag": "beach", "image": {"b64": "ASa8asdf"}},
- *                {"tag": "car", "image": {"b64": "JLK7ljk3"}}]}
+ * {
+ *   "instances": [
+ *     {
+ *       "tag": "beach",
+ *       "image": {"b64": "ASa8asdf"}
+ *     },
+ *     {
+ *       "tag": "car",
+ *       "image": {"b64": "JLK7ljk3"}
+ *     }
+ *   ]
+ * }
  * </pre>
  * For a graph with input tensor aliases "tag" (string) and "image"
  * (3-dimensional array of 8-bit ints):
  * <pre>
- * {"instances": [{"tag": "beach", "image": [[[263, 1, 10], [262, 2, 11],
- * ...]]},
- * {"tag": "car", "image": [[[10, 11, 24], [23, 10, 15], ...]]}]}
+ * {
+ *   "instances": [
+ *     {
+ *       "tag": "beach",
+ *       "image": [
+ *         [
+ *           [138, 30, 66],
+ *           [130, 20, 56],
+ *           ...
+ *         ],
+ *         [
+ *           [126, 38, 61],
+ *           [122, 24, 57],
+ *           ...
+ *         ],
+ *         ...
+ *       ]
+ *     },
+ *     {
+ *       "tag": "car",
+ *       "image": [
+ *         [
+ *           [255, 0, 102],
+ *           [255, 0, 97],
+ *           ...
+ *         ],
+ *         [
+ *           [254, 1, 101],
+ *           [254, 2, 93],
+ *           ...
+ *         ],
+ *         ...
+ *       ]
+ *     },
+ *     ...
+ *   ]
+ * }
  * </pre>
  * If the call is successful, the response body will contain one prediction
  * entry per instance in the request body. If prediction fails for any
  * instance, the response body will contain no predictions and will contian
  * a single error entry instead.
  */
 class GoogleCloudMlV1beta1PredictRequest {
   /**
    *
    * Required. The prediction request body.
@@ skipping 47 matching lines @@
    */
   core.String modelName;
   /** Required. The output Google Cloud Storage location. */
   core.String outputPath;
   /**
    * Required. The Google Compute Engine region to run the prediction job in.
    */
   core.String region;
   /**
    * Optional. The Google Cloud ML runtime version to use for this batch
-   * prediction. If not set, Google Cloud ML will choose a version.
+   * prediction. If not set, Google Cloud ML will pick the runtime version used
+   * during the CreateVersion request for this model version, or choose the
+   * latest stable version when model version information is not available
+   * such as when the model is specified by uri.
    */
   core.String runtimeVersion;
+  /** Use this field if you want to specify a GCS path to the model to use. */
+  core.String uri;
   /**
    * Use this field if you want to specify a version of the model to use. The
    * string is formatted the same way as `model_version`, with the addition
    * of the version information:
    *
    * `"projects/<var>[YOUR_PROJECT]</var>/models/<var>YOUR_MODEL/versions/<var>[YOUR_VERSION]</var>"`
    */
   core.String versionName;
 
   GoogleCloudMlV1beta1PredictionInput();
@@ skipping 13 matching lines @@
     }
     if (_json.containsKey("outputPath")) {
       outputPath = _json["outputPath"];
     }
     if (_json.containsKey("region")) {
       region = _json["region"];
     }
     if (_json.containsKey("runtimeVersion")) {
       runtimeVersion = _json["runtimeVersion"];
     }
+    if (_json.containsKey("uri")) {
+      uri = _json["uri"];
+    }
     if (_json.containsKey("versionName")) {
       versionName = _json["versionName"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (dataFormat != null) {
       _json["dataFormat"] = dataFormat;
     }
     if (inputPaths != null) {
       _json["inputPaths"] = inputPaths;
     }
     if (maxWorkerCount != null) {
       _json["maxWorkerCount"] = maxWorkerCount;
     }
     if (modelName != null) {
       _json["modelName"] = modelName;
     }
     if (outputPath != null) {
       _json["outputPath"] = outputPath;
     }
     if (region != null) {
       _json["region"] = region;
     }
     if (runtimeVersion != null) {
       _json["runtimeVersion"] = runtimeVersion;
     }
+    if (uri != null) {
+      _json["uri"] = uri;
+    }
     if (versionName != null) {
       _json["versionName"] = versionName;
     }
     return _json;
   }
 }
 
 /** Represents results of a prediction job. */
 class GoogleCloudMlV1beta1PredictionOutput {
   /** The number of data instances which resulted in errors. */
@@ skipping 56 matching lines @@
   }
 }
 
 /** Represents input parameters for a training job. */
 class GoogleCloudMlV1beta1TrainingInput {
   /** Optional. Command line arguments to pass to the program. */
   core.List<core.String> args;
   /** Optional. The set of Hyperparameters to tune. */
   GoogleCloudMlV1beta1HyperparameterSpec hyperparameters;
   /**
+   * Optional. A GCS path in which to store training outputs and other data
+   * needed for training. This path will be passed to your TensorFlow program as
+   * the 'job_dir' command-line arg. The benefit of specifying this field is
+   * that
+   * Cloud ML will validate the path for use in training.
+   */
+  core.String jobDir;
+  /**
    * Optional. Specifies the type of virtual machine to use for your training
    * job's master worker.
    *
    * The following types are supported:
    *
    * <dl>
    *   <dt>standard</dt>
    *   <dd>
    *   A basic machine configuration suitable for training simple models with
    *   small to moderate datasets.
@@ skipping 61 matching lines @@
   core.String runtimeVersion;
   /**
    * Required. Specifies the machine types, the number of replicas for workers
    * and parameter servers.
    * Possible string values are:
    * - "BASIC" : A single worker instance. This tier is suitable for learning
    * how to use
    * Cloud ML, and for experimenting with new models using small datasets.
    * - "STANDARD_1" : Many workers and a few parameter servers.
    * - "PREMIUM_1" : A large number of workers with many parameter servers.
+   * - "BASIC_GPU" : A single worker instance with a GPU.
    * - "CUSTOM" : The CUSTOM tier is not a set tier, but rather enables you to
    * use your
    * own cluster specification. When you use this tier, set values to
    * configure your processing cluster according to these guidelines:
    *
    * *   You _must_ set `TrainingInput.masterType` to specify the type
    *     of machine to use for your master node. This is the only required
    *     setting.
    *
    * *   You _may_ set `TrainingInput.workerCount` to specify the number of
@@ skipping 35 matching lines @@
 
   GoogleCloudMlV1beta1TrainingInput();
 
   GoogleCloudMlV1beta1TrainingInput.fromJson(core.Map _json) {
     if (_json.containsKey("args")) {
       args = _json["args"];
     }
     if (_json.containsKey("hyperparameters")) {
       hyperparameters = new GoogleCloudMlV1beta1HyperparameterSpec.fromJson(_json["hyperparameters"]);
     }
+    if (_json.containsKey("jobDir")) {
+      jobDir = _json["jobDir"];
+    }
     if (_json.containsKey("masterType")) {
       masterType = _json["masterType"];
     }
     if (_json.containsKey("packageUris")) {
       packageUris = _json["packageUris"];
     }
     if (_json.containsKey("parameterServerCount")) {
       parameterServerCount = _json["parameterServerCount"];
     }
     if (_json.containsKey("parameterServerType")) {
@@ skipping 20 matching lines @@
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (args != null) {
       _json["args"] = args;
     }
     if (hyperparameters != null) {
       _json["hyperparameters"] = (hyperparameters).toJson();
     }
+    if (jobDir != null) {
+      _json["jobDir"] = jobDir;
+    }
     if (masterType != null) {
       _json["masterType"] = masterType;
     }
     if (packageUris != null) {
       _json["packageUris"] = packageUris;
     }
     if (parameterServerCount != null) {
       _json["parameterServerCount"] = parameterServerCount;
     }
     if (parameterServerType != null) {
@@ skipping 111 matching lines @@
   core.bool isDefault;
   /** Output only. The time the version was last used for prediction. */
   core.String lastUseTime;
   /**
    * Required.The name specified for the version when it was created.
    *
    * The version name must be unique within the model it is created in.
    */
   core.String name;
   /**
-   * Optional. If true, enables StackDriver Logging for online prediction.
-   * Default is false.
-   */
-  core.bool onlinePredictionLogging;
-  /**
    * Optional. The Google Cloud ML runtime version to use for this deployment.
    * If not set, Google Cloud ML will choose a version.
    */
   core.String runtimeVersion;
 
   GoogleCloudMlV1beta1Version();
 
   GoogleCloudMlV1beta1Version.fromJson(core.Map _json) {
     if (_json.containsKey("createTime")) {
       createTime = _json["createTime"];
     }
     if (_json.containsKey("deploymentUri")) {
       deploymentUri = _json["deploymentUri"];
     }
     if (_json.containsKey("description")) {
       description = _json["description"];
     }
     if (_json.containsKey("isDefault")) {
       isDefault = _json["isDefault"];
     }
     if (_json.containsKey("lastUseTime")) {
       lastUseTime = _json["lastUseTime"];
     }
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
-    if (_json.containsKey("onlinePredictionLogging")) {
-      onlinePredictionLogging = _json["onlinePredictionLogging"];
-    }
     if (_json.containsKey("runtimeVersion")) {
       runtimeVersion = _json["runtimeVersion"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (createTime != null) {
       _json["createTime"] = createTime;
     }
     if (deploymentUri != null) {
       _json["deploymentUri"] = deploymentUri;
     }
     if (description != null) {
       _json["description"] = description;
     }
     if (isDefault != null) {
       _json["isDefault"] = isDefault;
     }
     if (lastUseTime != null) {
       _json["lastUseTime"] = lastUseTime;
     }
     if (name != null) {
       _json["name"] = name;
     }
-    if (onlinePredictionLogging != null) {
-      _json["onlinePredictionLogging"] = onlinePredictionLogging;
-    }
     if (runtimeVersion != null) {
       _json["runtimeVersion"] = runtimeVersion;
     }
     return _json;
   }
 }
 
 /** The response message for Operations.ListOperations. */
 class GoogleLongrunningListOperationsResponse {
   /** The standard List next-page token. */
@@ skipping 228 matching lines @@
     }
     if (details != null) {
       _json["details"] = details;
     }
     if (message != null) {
       _json["message"] = message;
     }
     return _json;
   }
 }