Api-Roll 52: 2017-07-31

generated/googleapis/lib/ml/v1.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis.ml.v1;
 
 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 1276 matching lines @@
       _json["objectiveValue"] = objectiveValue;
     }
     if (trainingStep != null) {
       _json["trainingStep"] = trainingStep;
     }
     return _json;
   }
 }
 
 /** Options for automatically scaling a model. */
-class GoogleCloudMlV1AutomaticScaling {
+class GoogleCloudMlV1AutoScaling {
   /**
    * Optional. The minimum number of nodes to allocate for this model. These
    * nodes are always up, starting from the time the model is deployed, so the
    * cost of operating this model will be at least
    * `rate` * `min_nodes` * number of hours since last billing cycle,
    * where `rate` is the cost per node-hour as documented in
    * [pricing](https://cloud.google.com/ml-engine/pricing#prediction_pricing),
    * even if no predictions are performed. There is additional cost for each
    * prediction performed.
    *
    * Unlike manual scaling, if the load gets too heavy for the nodes
    * that are up, the service will automatically add nodes to handle the
    * increased load as well as scale back as traffic drops, always maintaining
    * at least `min_nodes`. You will be charged for the time in which additional
    * nodes are used.
    *
    * If not specified, `min_nodes` defaults to 0, in which case, when traffic
    * to a model stops (and after a cool-down period), nodes will be shut down
    * and no charges will be incurred until traffic to the model resumes.
    */
   core.int minNodes;
 
-  GoogleCloudMlV1AutomaticScaling();
+  GoogleCloudMlV1AutoScaling();
 
-  GoogleCloudMlV1AutomaticScaling.fromJson(core.Map _json) {
+  GoogleCloudMlV1AutoScaling.fromJson(core.Map _json) {
     if (_json.containsKey("minNodes")) {
       minNodes = _json["minNodes"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (minNodes != null) {
       _json["minNodes"] = minNodes;
     }
@@ skipping 1396 matching lines @@
  * information about all of the versions of a given model by calling
  * [projects.models.versions.list](/ml-engine/reference/rest/v1/projects.models.versions/list).
  */
 class GoogleCloudMlV1Version {
   /**
    * Automatically scale the number of nodes used to serve the model in
    * response to increases and decreases in traffic. Care should be
    * taken to ramp up traffic according to the model's ability to scale
    * or you will start seeing increases in latency and 429 response codes.
    */
-  GoogleCloudMlV1AutomaticScaling automaticScaling;
+  GoogleCloudMlV1AutoScaling autoScaling;
   /** 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-engine/docs/concepts/deployment-overview) for more
-   * informaiton.
+   * information.
    *
    * When passing Version to
    * [projects.models.versions.create](/ml-engine/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.
    * The total number of model files can't exceed 1000.
    */
   core.String deploymentUri;
   /**
    * Optional. The description specified for the version when it was created.
    */
   core.String description;
   /** Output only. The details of a failure or a cancellation. */
   core.String errorMessage;
   /**
    * 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-engine/reference/rest/v1/projects.models.versions/setDefault).
    */
   core.bool isDefault;
   /** Output only. The time the version was last used for prediction. */
   core.String lastUseTime;
   /**
    * Manually select the number of nodes to use for serving the
-   * model. You should generally use `automatic_scaling` with an appropriate
+   * model. You should generally use `auto_scaling` with an appropriate
    * `min_nodes` instead, but this option is available if you want more
    * predictable billing. Beware that latency and error rates will increase
    * if the traffic exceeds that capability of the system to serve it based
    * on the selected number of nodes.
    */
   GoogleCloudMlV1ManualScaling manualScaling;
   /**
    * Required.The name specified for the version when it was created.
    *
    * The version name must be unique within the model it is created in.
@@ skipping 11 matching lines @@
    * - "READY" : The version is ready for prediction.
    * - "CREATING" : The version is still in the process of creation.
    * - "FAILED" : The version failed to be created, possibly cancelled.
    * `error_message` should contain the details of the failure.
    */
   core.String state;
 
   GoogleCloudMlV1Version();
 
   GoogleCloudMlV1Version.fromJson(core.Map _json) {
-    if (_json.containsKey("automaticScaling")) {
-      automaticScaling = new GoogleCloudMlV1AutomaticScaling.fromJson(_json["automaticScaling"]);
+    if (_json.containsKey("autoScaling")) {
+      autoScaling = new GoogleCloudMlV1AutoScaling.fromJson(_json["autoScaling"]);
     }
     if (_json.containsKey("createTime")) {
       createTime = _json["createTime"];
     }
     if (_json.containsKey("deploymentUri")) {
       deploymentUri = _json["deploymentUri"];
     }
     if (_json.containsKey("description")) {
       description = _json["description"];
     }
@@ skipping 15 matching lines @@
     if (_json.containsKey("runtimeVersion")) {
       runtimeVersion = _json["runtimeVersion"];
     }
     if (_json.containsKey("state")) {
       state = _json["state"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
-    if (automaticScaling != null) {
-      _json["automaticScaling"] = (automaticScaling).toJson();
+    if (autoScaling != null) {
+      _json["autoScaling"] = (autoScaling).toJson();
     }
     if (createTime != null) {
       _json["createTime"] = createTime;
     }
     if (deploymentUri != null) {
       _json["deploymentUri"] = deploymentUri;
     }
     if (description != null) {
       _json["description"] = description;
     }
@@ skipping 16 matching lines @@
       _json["runtimeVersion"] = runtimeVersion;
     }
     if (state != null) {
       _json["state"] = state;
     }
     return _json;
   }
 }
 
 /** Options for automatically scaling a model. */
-class GoogleCloudMlV1beta1AutomaticScaling {
+class GoogleCloudMlV1beta1AutoScaling {
   /**
    * Optional. The minimum number of nodes to allocate for this model. These
    * nodes are always up, starting from the time the model is deployed, so the
    * cost of operating this model will be at least
    * `rate` * `min_nodes` * number of hours since last billing cycle,
    * where `rate` is the cost per node-hour as documented in
    * [pricing](https://cloud.google.com/ml-engine/pricing#prediction_pricing),
    * even if no predictions are performed. There is additional cost for each
    * prediction performed.
    *
    * Unlike manual scaling, if the load gets too heavy for the nodes
    * that are up, the service will automatically add nodes to handle the
    * increased load as well as scale back as traffic drops, always maintaining
    * at least `min_nodes`. You will be charged for the time in which additional
    * nodes are used.
    *
    * If not specified, `min_nodes` defaults to 0, in which case, when traffic
    * to a model stops (and after a cool-down period), nodes will be shut down
    * and no charges will be incurred until traffic to the model resumes.
    */
   core.int minNodes;
 
-  GoogleCloudMlV1beta1AutomaticScaling();
+  GoogleCloudMlV1beta1AutoScaling();
 
-  GoogleCloudMlV1beta1AutomaticScaling.fromJson(core.Map _json) {
+  GoogleCloudMlV1beta1AutoScaling.fromJson(core.Map _json) {
     if (_json.containsKey("minNodes")) {
       minNodes = _json["minNodes"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (minNodes != null) {
       _json["minNodes"] = minNodes;
     }
     return _json;
   }
 }
 
 /** Options for manually scaling a model. */
 class GoogleCloudMlV1beta1ManualScaling {
   /**
    * The number of nodes to allocate for this model. These nodes are always up,
    * starting from the time the model is deployed, so the cost of operating
    * this model will be proportional to `nodes` * number of hours since
-   * last billing cycle.
+   * last billing cycle plus the cost for each prediction performed.
    */
   core.int nodes;
 
   GoogleCloudMlV1beta1ManualScaling();
 
   GoogleCloudMlV1beta1ManualScaling.fromJson(core.Map _json) {
     if (_json.containsKey("nodes")) {
       nodes = _json["nodes"];
     }
   }
@@ skipping 92 matching lines @@
  * information about all of the versions of a given model by calling
  * [projects.models.versions.list](/ml-engine/reference/rest/v1beta1/projects.models.versions/list).
  */
 class GoogleCloudMlV1beta1Version {
   /**
    * Automatically scale the number of nodes used to serve the model in
    * response to increases and decreases in traffic. Care should be
    * taken to ramp up traffic according to the model's ability to scale
    * or you will start seeing increases in latency and 429 response codes.
    */
-  GoogleCloudMlV1beta1AutomaticScaling automaticScaling;
+  GoogleCloudMlV1beta1AutoScaling autoScaling;
   /** 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-engine/docs/concepts/deployment-overview) for more
-   * informaiton.
+   * information.
    *
    * When passing Version to
    * [projects.models.versions.create](/ml-engine/reference/rest/v1beta1/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.
    * The total number of model files can't exceed 1000.
    */
   core.String deploymentUri;
   /**
    * Optional. The description specified for the version when it was created.
    */
   core.String description;
   /** Output only. The details of a failure or a cancellation. */
   core.String errorMessage;
   /**
    * 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-engine/reference/rest/v1beta1/projects.models.versions/setDefault).
    */
   core.bool isDefault;
   /** Output only. The time the version was last used for prediction. */
   core.String lastUseTime;
   /**
    * Manually select the number of nodes to use for serving the
-   * model. You should generally use `automatic_scaling` with an appropriate
-   * `min_nodes` instead, but this option is available if you want predictable
-   * billing. Beware that latency and error rates will increase if the
-   * traffic exceeds that capability of the system to serve it based on
-   * the selected number of nodes.
+   * model. You should generally use `auto_scaling` with an appropriate
+   * `min_nodes` instead, but this option is available if you want more
+   * predictable billing. Beware that latency and error rates will increase
+   * if the traffic exceeds that capability of the system to serve it based
+   * on the selected number of nodes.
    */
   GoogleCloudMlV1beta1ManualScaling manualScaling;
   /**
    * 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;
   /**
    * Output only. The state of a version.
    * Possible string values are:
-   * - "UNKNOWN" : / The version state is unspecified.
+   * - "UNKNOWN" : The version state is unspecified.
    * - "READY" : The version is ready for prediction.
    * - "CREATING" : The version is still in the process of creation.
    * - "FAILED" : The version failed to be created, possibly cancelled.
    * `error_message` should contain the details of the failure.
    */
   core.String state;
 
   GoogleCloudMlV1beta1Version();
 
   GoogleCloudMlV1beta1Version.fromJson(core.Map _json) {
-    if (_json.containsKey("automaticScaling")) {
-      automaticScaling = new GoogleCloudMlV1beta1AutomaticScaling.fromJson(_json["automaticScaling"]);
+    if (_json.containsKey("autoScaling")) {
+      autoScaling = new GoogleCloudMlV1beta1AutoScaling.fromJson(_json["autoScaling"]);
     }
     if (_json.containsKey("createTime")) {
       createTime = _json["createTime"];
     }
     if (_json.containsKey("deploymentUri")) {
       deploymentUri = _json["deploymentUri"];
     }
     if (_json.containsKey("description")) {
       description = _json["description"];
     }
@@ skipping 15 matching lines @@
     if (_json.containsKey("runtimeVersion")) {
       runtimeVersion = _json["runtimeVersion"];
     }
     if (_json.containsKey("state")) {
       state = _json["state"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
     final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
-    if (automaticScaling != null) {
-      _json["automaticScaling"] = (automaticScaling).toJson();
+    if (autoScaling != null) {
+      _json["autoScaling"] = (autoScaling).toJson();
     }
     if (createTime != null) {
       _json["createTime"] = createTime;
     }
     if (deploymentUri != null) {
       _json["deploymentUri"] = deploymentUri;
     }
     if (description != null) {
       _json["description"] = description;
     }
@@ skipping 1000 matching lines @@
  *     results in its response, the status of those operations should be
  *     represented directly using the `Status` message.
  *
  * - Logging. If some API errors are stored in logs, the message `Status` could
  * be used directly after any stripping needed for security/privacy reasons.
  */
 class GoogleRpcStatus {
   /** The status code, which should be an enum value of google.rpc.Code. */
   core.int code;
   /**
-   * A list of messages that carry the error details.  There will be a
-   * common set of message types for APIs to use.
+   * A list of messages that carry the error details.  There is a common set of
+   * message types for APIs to use.
    *
    * 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.List<core.Map<core.String, core.Object>> details;
   /**
    * A developer-facing error message, which should be in English. Any
    * user-facing error message should be localized and sent in the
    * google.rpc.Status.details field, or localized by the client.
    */
@@ skipping 88 matching lines @@
     }
     if (location != null) {
       _json["location"] = location;
     }
     if (title != null) {
       _json["title"] = title;
     }
     return _json;
   }
 }