Api-Roll 52: 2017-07-31

generated/googleapis/lib/clouddebugger/v2.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis.clouddebugger.v2;
 
 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 96 matching lines @@
 
 class ControllerDebuggeesBreakpointsResourceApi {
   final commons.ApiRequester _requester;
 
   ControllerDebuggeesBreakpointsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Returns the list of all active breakpoints for the debuggee.
    *
-   * The breakpoint specification (location, condition, and expression
+   * The breakpoint specification (`location`, `condition`, and `expressions`
    * fields) is semantically immutable, although the field values may
    * change. For example, an agent may update the location line number
    * to reflect the actual line where the breakpoint was set, but this
    * doesn't change the breakpoint semantics.
    *
    * This means that an agent does not need to check if a breakpoint has changed
    * when it encounters the same breakpoint on a successive call.
    * Moreover, an agent should remember the breakpoints that are completed
    * until the controller removes them from the active list to avoid
    * setting those breakpoints again.
@@ skipping 53 matching lines @@
     return _response.then((data) => new ListActiveBreakpointsResponse.fromJson(data));
   }
 
   /**
    * Updates the breakpoint state or mutable fields.
    * The entire Breakpoint message must be sent back to the controller
    * service.
    *
    * Updates to active breakpoint fields are only allowed if the new value
    * does not change the breakpoint specification. Updates to the `location`,
-   * `condition` and `expression` fields should not alter the breakpoint
+   * `condition` and `expressions` fields should not alter the breakpoint
    * semantics. These may only make changes such as canonicalizing a value
    * or snapping the location to the correct line of code.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [debuggeeId] - Identifies the debuggee being debugged.
    *
    * [id] - Breakpoint identifier, unique in the scope of the debuggee.
@@ skipping 55 matching lines @@
   DebuggerDebuggeesBreakpointsResourceApi get breakpoints => new DebuggerDebuggeesBreakpointsResourceApi(_requester);
 
   DebuggerDebuggeesResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Lists all the debuggees that the user can set breakpoints to.
    *
    * Request parameters:
    *
-   * [clientVersion] - The client version making the call.
-   * Following: `domain/type/version` (e.g., `google.com/intellij/v1`).
-   *
    * [includeInactive] - When set to `true`, the result includes all debuggees.
    * Otherwise, the
    * result includes only debuggees that are active.
    *
    * [project] - Project number of a Google Cloud project whose debuggees to
    * list.
    *
+   * [clientVersion] - The client version making the call.
+   * Following: `domain/type/version` (e.g., `google.com/intellij/v1`).
+   *
    * Completes with a [ListDebuggeesResponse].
    *
    * 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<ListDebuggeesResponse> list({core.String clientVersion, core.bool includeInactive, core.String project}) {
+  async.Future<ListDebuggeesResponse> list({core.bool includeInactive, core.String project, core.String clientVersion}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
-    if (clientVersion != null) {
-      _queryParams["clientVersion"] = [clientVersion];
-    }
     if (includeInactive != null) {
       _queryParams["includeInactive"] = ["${includeInactive}"];
     }
     if (project != null) {
       _queryParams["project"] = [project];
     }
+    if (clientVersion != null) {
+      _queryParams["clientVersion"] = [clientVersion];
+    }
 
     _url = 'v2/debugger/debuggees';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 109 matching lines @@
     return _response.then((data) => new GetBreakpointResponse.fromJson(data));
   }
 
   /**
    * Lists all breakpoints for the debuggee.
    *
    * Request parameters:
    *
    * [debuggeeId] - ID of the debuggee whose breakpoints to list.
    *
-   * [stripResults] - This field is deprecated. The following fields are always
-   * stripped out of
-   * the result: `stack_frames`, `evaluated_expressions` and `variable_table`.
-   *
    * [waitToken] - A wait token that, if specified, blocks the call until the
    * breakpoints
    * list has changed, or a server selected timeout has expired.  The value
    * should be set from the last response. The error code
    * `google.rpc.Code.ABORTED` (RPC) is returned on wait timeout, which
    * should be called again with the same `wait_token`.
    *
    * [clientVersion] - The client version making the call.
    * Following: `domain/type/version` (e.g., `google.com/intellij/v1`).
    *
    * [action_value] - Only breakpoints with the specified action will pass the
    * filter.
    * Possible string values are:
    * - "CAPTURE" : A CAPTURE.
    * - "LOG" : A LOG.
    *
+   * [includeInactive] - When set to `true`, the response includes active and
+   * inactive
+   * breakpoints. Otherwise, it includes only active breakpoints.
+   *
    * [includeAllUsers] - When set to `true`, the response includes the list of
    * breakpoints set by
    * any user. Otherwise, it includes only breakpoints set by the caller.
    *
-   * [includeInactive] - When set to `true`, the response includes active and
-   * inactive
-   * breakpoints. Otherwise, it includes only active breakpoints.
+   * [stripResults] - This field is deprecated. The following fields are always
+   * stripped out of
+   * the result: `stack_frames`, `evaluated_expressions` and `variable_table`.
    *
    * Completes with a [ListBreakpointsResponse].
    *
    * 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<ListBreakpointsResponse> list(core.String debuggeeId, {core.bool stripResults, core.String waitToken, core.String clientVersion, core.String action_value, core.bool includeAllUsers, core.bool includeInactive}) {
+  async.Future<ListBreakpointsResponse> list(core.String debuggeeId, {core.String waitToken, core.String clientVersion, core.String action_value, core.bool includeInactive, core.bool includeAllUsers, core.bool stripResults}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (debuggeeId == null) {
       throw new core.ArgumentError("Parameter debuggeeId is required.");
     }
-    if (stripResults != null) {
-      _queryParams["stripResults"] = ["${stripResults}"];
-    }
     if (waitToken != null) {
       _queryParams["waitToken"] = [waitToken];
     }
     if (clientVersion != null) {
       _queryParams["clientVersion"] = [clientVersion];
     }
     if (action_value != null) {
       _queryParams["action.value"] = [action_value];
     }
+    if (includeInactive != null) {
+      _queryParams["includeInactive"] = ["${includeInactive}"];
+    }
     if (includeAllUsers != null) {
       _queryParams["includeAllUsers"] = ["${includeAllUsers}"];
     }
-    if (includeInactive != null) {
-      _queryParams["includeInactive"] = ["${includeInactive}"];
+    if (stripResults != null) {
+      _queryParams["stripResults"] = ["${stripResults}"];
     }
 
     _url = 'v2/debugger/debuggees/' + commons.Escaper.ecapeVariable('$debuggeeId') + '/breakpoints';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
@@ skipping 851 matching lines @@
     return _json;
   }
 }
 
 /** Response for listing breakpoints. */
 class ListBreakpointsResponse {
   /**
    * List of breakpoints matching the request.
    * The fields `id` and `location` are guaranteed to be set on each breakpoint.
    * The fields: `stack_frames`, `evaluated_expressions` and `variable_table`
-   * are cleared on each breakpoint regardless of it's status.
+   * are cleared on each breakpoint regardless of its status.
    */
   core.List<Breakpoint> breakpoints;
   /**
    * A wait token that can be used in the next call to `list` (REST) or
    * `ListBreakpoints` (RPC) to block until the list of breakpoints has changes.
    */
   core.String nextWaitToken;
 
   ListBreakpointsResponse();
 
@@ skipping 374 matching lines @@
       _json["refersTo"] = refersTo;
     }
     return _json;
   }
 }
 
 /** Request to update an active breakpoint. */
 class UpdateActiveBreakpointRequest {
   /**
    * Updated breakpoint information.
-   * The field 'id' must be set.
+   * The field `id` must be set.
    */
   Breakpoint breakpoint;
 
   UpdateActiveBreakpointRequest();
 
   UpdateActiveBreakpointRequest.fromJson(core.Map _json) {
     if (_json.containsKey("breakpoint")) {
       breakpoint = new Breakpoint.fromJson(_json["breakpoint"]);
     }
   }
@@ skipping 217 matching lines @@
     }
     if (value != null) {
       _json["value"] = value;
     }
     if (varTableIndex != null) {
       _json["varTableIndex"] = varTableIndex;
     }
     return _json;
   }
 }