Api roll 7: 2014-12-01

generated/googleapis_beta/lib/replicapoolupdater/v1beta1.dart

 library googleapis_beta.replicapoolupdater.v1beta1;
 
 import "dart:core" as core;
 import "dart:collection" as collection;
 import "dart:async" as async;
 import "dart:convert" as convert;
 
 import "package:crypto/crypto.dart" as crypto;
 import 'package:http/http.dart' as http;
 import '../src/common_internal.dart' as common_internal;
@@ skipping 263 matching lines @@
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new UpdateList.fromJson(data));
   }
 
   /**
-   * Called on the particular Update endpoint. Pauses the update in state from {
-   * ROLLING_FORWARD, ROLLING_BACK, PAUSED }. No-op if invoked in state PAUSED.
+   * Called on the particular Update endpoint. Pauses the update in state
+   * ROLLING_FORWARD or ROLLING_BACK. No-op if invoked in state PAUSED.
    *
    * Request parameters:
    *
    * [project] - Project ID for this request.
    *
    * [zone] - Zone for the instance group manager.
    *
    * [instanceGroupManager] - Name of the instance group manager for this
    * request.
    *
@@ skipping 35 matching lines @@
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
 
   /**
    * Called on the particular Update endpoint. Rolls back the update in state
-   * from { ROLLING_FORWARD, ROLLING_BACK, PAUSED }. No-op if invoked in state
-   * ROLLED_BACK.
+   * ROLLING_FORWARD or PAUSED. No-op if invoked in state ROLLED_BACK or
+   * ROLLING_BACK.
    *
    * Request parameters:
    *
    * [project] - Project ID for this request.
    *
    * [zone] - Zone for the instance group manager.
    *
    * [instanceGroupManager] - Name of the instance group manager for this
    * request.
    *
@@ skipping 35 matching lines @@
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
 
   /**
    * Called on the particular Update endpoint. Rolls forward the update in state
-   * from { ROLLING_FORWARD, ROLLING_BACK, PAUSED }. No-op if invoked in state
-   * ROLLED_OUT.
+   * ROLLING_BACK or PAUSED. No-op if invoked in state ROLLED_OUT or
+   * ROLLING_FORWARD.
    *
    * Request parameters:
    *
    * [project] - Project ID for this request.
    *
    * [zone] - Zone for the instance group manager.
    *
    * [instanceGroupManager] - Name of the instance group manager for this
    * request.
    *
@@ skipping 66 matching lines @@
     return _json;
   }
 }
 
 
 /** Update of a single instance. */
 class InstanceUpdate {
   /** Name of an instance. */
   core.String instanceName;
 
-  /** State of an instance update. */
+  /**
+   * State of an instance update. Possible values are:
+   * - "PENDING/code>": The instance update is pending execution.
+   * - "ROLLING_FORWARD": The instance update is going forward.
+   * - "ROLLING_BACK": The instance update being rolled back.
+   * - "PAUSED": The instance update is temporarily paused (inactive).
+   * - "ROLLED_OUT": The instance update is finished, the instance is running
+   * the new template.
+   * - "ROLLED_BACK": The instance update is finished, the instance has been
+   * reverted to the previous template.
+   * - "CANCELLED": The instance update is paused and no longer can be resumed,
+   * undefined in which template the instance is running.
+   */
   core.String state;
 
 
   InstanceUpdate();
 
   InstanceUpdate.fromJson(core.Map _json) {
     if (_json.containsKey("instanceName")) {
       instanceName = _json["instanceName"];
     }
     if (_json.containsKey("state")) {
@@ skipping 12 matching lines @@
     return _json;
   }
 }
 
 
 /**
  * Resource describing a single update (rollout) of an instance group to the
  * given template.
  */
 class Update {
-  /** [Output Only] Human-readable description of an update progress. */
+  /** [Output only] The time the update was created, in RFC3339 text format. */
+  core.String creationTimestamp;
+
+  /** [Output only] Human-readable description of an update progress. */
   core.String details;
 
   /**
-   * [Output Only] Unique (in the context of a group) handle assigned to this
+   * [Output only] Unique (in the context of a group) handle assigned to this
    * update.
    */
   core.String handle;
 
   /** Url of an instance template to be applied. */
   core.String instanceTemplate;
 
-  /** [Output Only] Collection of instance updates. */
+  /** [Output only] Collection of instance updates. */
   core.List<InstanceUpdate> instanceUpdates;
 
   /** [Output only] The resource type. Always replicapoolupdater#update. */
   core.String kind;
 
   /** Parameters of an update process. */
   UpdatePolicy policy;
 
   /** [Output only] The fully qualified URL for this resource. */
   core.String selfLink;
 
-  /** [Output Only] Current state of an update. */
+  /**
+   * [Output only] Current state of an update. Possible values are:
+   * - "ROLLING_FORWARD": The update is going forward.
+   * - "ROLLING_BACK": The update is being rolled back.
+   * - "PAUSED": The update is temporarily paused (inactive).
+   * - "ROLLED_OUT": The update is finished, all instances have been updated
+   * successfully.
+   * - "ROLLED_BACK": The update is finished, all instances have been reverted
+   * to the previous template.
+   * - "CANCELLED": The update is paused and no longer can be resumed, undefined
+   * how many instances are running in which template.
+   */
   core.String state;
 
   /**
-   * [Output Only] Requested state of an update. This is the state that the
+   * [Output only] Requested state of an update. This is the state that the
    * updater is moving towards. Acceptable values are:
    * - "ROLLED_OUT": The user has requested the update to go forward.
    * - "ROLLED_BACK": The user has requested the update to be rolled back.
    * - "PAUSED": The user has requested the update to be paused.
    *
    * - "CANCELLED": The user has requested the update to be cancelled. The
    * updater service is in the process of canceling the update.
    */
   core.String targetState;
 
+  /**
+   * [Output only] User who requested the update, for example: user@example.com.
+   */
+  core.String user;
+
 
   Update();
 
   Update.fromJson(core.Map _json) {
+    if (_json.containsKey("creationTimestamp")) {
+      creationTimestamp = _json["creationTimestamp"];
+    }
     if (_json.containsKey("details")) {
       details = _json["details"];
     }
     if (_json.containsKey("handle")) {
       handle = _json["handle"];
     }
     if (_json.containsKey("instanceTemplate")) {
       instanceTemplate = _json["instanceTemplate"];
     }
     if (_json.containsKey("instanceUpdates")) {
       instanceUpdates = _json["instanceUpdates"].map((value) => new InstanceUpdate.fromJson(value)).toList();
     }
     if (_json.containsKey("kind")) {
       kind = _json["kind"];
     }
     if (_json.containsKey("policy")) {
       policy = new UpdatePolicy.fromJson(_json["policy"]);
     }
     if (_json.containsKey("selfLink")) {
       selfLink = _json["selfLink"];
     }
     if (_json.containsKey("state")) {
       state = _json["state"];
     }
     if (_json.containsKey("targetState")) {
       targetState = _json["targetState"];
     }
+    if (_json.containsKey("user")) {
+      user = _json["user"];
+    }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
+    if (creationTimestamp != null) {
+      _json["creationTimestamp"] = creationTimestamp;
+    }
     if (details != null) {
       _json["details"] = details;
     }
     if (handle != null) {
       _json["handle"] = handle;
     }
     if (instanceTemplate != null) {
       _json["instanceTemplate"] = instanceTemplate;
     }
     if (instanceUpdates != null) {
       _json["instanceUpdates"] = instanceUpdates.map((value) => (value).toJson()).toList();
     }
     if (kind != null) {
       _json["kind"] = kind;
     }
     if (policy != null) {
       _json["policy"] = (policy).toJson();
     }
     if (selfLink != null) {
       _json["selfLink"] = selfLink;
     }
     if (state != null) {
       _json["state"] = state;
     }
     if (targetState != null) {
       _json["targetState"] = targetState;
     }
+    if (user != null) {
+      _json["user"] = user;
+    }
     return _json;
   }
 }
 
 
 /** Response returned by List method. */
 class UpdateList {
   /** Collection of requested updates. */
   core.List<Update> items;
 
@@ skipping 95 matching lines @@
   core.Map toJson() {
     var _json = new core.Map();
     if (numInstances != null) {
       _json["numInstances"] = numInstances;
     }
     return _json;
   }
 }