Api-Roll 50: 2017-06-12

generated/googleapis/lib/firebaserules/v1.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis.firebaserules.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 274 matching lines @@
    * filtered by `Release` name, `Ruleset` name, `TestSuite` name, or any
    * combination thereof.
    *
    * Request parameters:
    *
    * [name] - Resource name for the project.
    *
    * Format: `projects/{project_id}`
    * Value must have pattern "^projects/[^/]+$".
    *
+   * [pageToken] - Next page token for the next batch of `Release` instances.
+   *
+   * [pageSize] - Page size to load. Maximum of 100. Defaults to 10.
+   * Note: `page_size` is just a hint and the service may choose to load fewer
+   * than `page_size` results due to the size of the output. To traverse all of
+   * the releases, the caller should iterate until the `page_token` on the
+   * response is empty.
+   *
    * [filter] - `Release` filter. The list method supports filters with
    * restrictions on the
    * `Release.name`, `Release.ruleset_name`, and `Release.test_suite_name`.
    *
    * Example 1: A filter of 'name=prod*' might return `Release`s with names
    * within 'projects/foo' prefixed with 'prod':
    *
    * Name                          | Ruleset Name
    * ------------------------------|-------------
    * projects/foo/releases/prod    | projects/foo/rulesets/uuid1234
    * projects/foo/releases/prod/v1 | projects/foo/rulesets/uuid1234
    * projects/foo/releases/prod/v2 | projects/foo/rulesets/uuid8888
    *
    * Example 2: A filter of `name=prod* ruleset_name=uuid1234` would return only
    * `Release` instances for 'projects/foo' with names prefixed with 'prod'
    * referring to the same `Ruleset` name of 'uuid1234':
    *
    * Name                          | Ruleset Name
    * ------------------------------|-------------
    * projects/foo/releases/prod    | projects/foo/rulesets/1234
    * projects/foo/releases/prod/v1 | projects/foo/rulesets/1234
    *
    * In the examples, the filter parameters refer to the search filters are
    * relative to the project. Fully qualified prefixed may also be used. e.g.
    * `test_suite_name=projects/foo/testsuites/uuid1`
    *
-   * [pageToken] - Next page token for the next batch of `Release` instances.
-   *
-   * [pageSize] - Page size to load. Maximum of 100. Defaults to 10.
-   * Note: `page_size` is just a hint and the service may choose to load fewer
-   * than `page_size` results due to the size of the output. To traverse all of
-   * the releases, the caller should iterate until the `page_token` on the
-   * response is empty.
-   *
    * Completes with a [ListReleasesResponse].
    *
    * 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<ListReleasesResponse> list(core.String name, {core.String filter, core.String pageToken, core.int pageSize}) {
+  async.Future<ListReleasesResponse> list(core.String name, {core.String pageToken, core.int pageSize, core.String filter}) {
     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 (filter != null) {
-      _queryParams["filter"] = [filter];
-    }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
     if (pageSize != null) {
       _queryParams["pageSize"] = ["${pageSize}"];
     }
+    if (filter != null) {
+      _queryParams["filter"] = [filter];
+    }
 
     _url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name') + '/releases';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 288 matching lines @@
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ListRulesetsResponse.fromJson(data));
   }
 
 }
 
 
 
+/** Arg matchers for the mock function. */
+class Arg {
+  /** Argument matches any value provided. */
+  Empty anyValue;
+  /**
+   * Argument exactly matches value provided.
+   *
+   * 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 exactValue;
+
+  Arg();
+
+  Arg.fromJson(core.Map _json) {
+    if (_json.containsKey("anyValue")) {
+      anyValue = new Empty.fromJson(_json["anyValue"]);
+    }
+    if (_json.containsKey("exactValue")) {
+      exactValue = _json["exactValue"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (anyValue != null) {
+      _json["anyValue"] = (anyValue).toJson();
+    }
+    if (exactValue != null) {
+      _json["exactValue"] = exactValue;
+    }
+    return _json;
+  }
+}
+
 /**
  * A generic empty message that you can re-use to avoid defining duplicated
  * empty messages in your APIs. A typical example is to use it as the request
  * or the response type of an API method. For instance:
  *
  *     service Foo {
  *       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
  *     }
  *
  * The JSON representation for `Empty` is empty JSON object `{}`.
  */
 class Empty {
 
   Empty();
 
   Empty.fromJson(core.Map _json) {
   }
 
-  core.Map toJson() {
-    var _json = new core.Map();
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     return _json;
   }
 }
 
 /** `File` containing source content. */
 class File {
   /** Textual Content. */
   core.String content;
   /** Fingerprint (e.g. github sha) associated with the `File`. */
   core.String fingerprint;
@@ skipping 14 matching lines @@
       content = _json["content"];
     }
     if (_json.containsKey("fingerprint")) {
       fingerprint = _json["fingerprint"];
     }
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
   }
 
-  core.Map toJson() {
-    var _json = new core.Map();
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (content != null) {
       _json["content"] = content;
     }
     if (fingerprint != null) {
       _json["fingerprint"] = fingerprint;
     }
     if (name != null) {
       _json["name"] = name;
     }
     return _json;
@@ skipping 19 matching lines @@
 
   FunctionCall.fromJson(core.Map _json) {
     if (_json.containsKey("args")) {
       args = _json["args"];
     }
     if (_json.containsKey("function")) {
       function = _json["function"];
     }
   }
 
-  core.Map toJson() {
-    var _json = new core.Map();
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (args != null) {
       _json["args"] = args;
     }
     if (function != null) {
       _json["function"] = function;
     }
     return _json;
   }
 }
 
+/**
+ * Mock function definition.
+ *
+ * Mocks must refer to a function declared by the target service. The type of
+ * the function args and result will be inferred at test time. If either the
+ * arg or result values are not compatible with function type declaration, the
+ * request will be considered invalid.
+ *
+ * More than one `FunctionMock` may be provided for a given function name so
+ * long as the `Arg` matchers are distinct. There may be only one function
+ * for a given overload where all `Arg` values are `Arg.any_value`.
+ */
+class FunctionMock {
+  /**
+   * The list of `Arg` values to match. The order in which the arguments are
+   * provided is the order in which they must appear in the function
+   * invocation.
+   */
+  core.List<Arg> args;
+  /**
+   * The name of the function.
+   *
+   * The function name must match one provided by a service declaration.
+   */
+  core.String function;
+  /** The mock result of the function call. */
+  Result result;
+
+  FunctionMock();
+
+  FunctionMock.fromJson(core.Map _json) {
+    if (_json.containsKey("args")) {
+      args = _json["args"].map((value) => new Arg.fromJson(value)).toList();
+    }
+    if (_json.containsKey("function")) {
+      function = _json["function"];
+    }
+    if (_json.containsKey("result")) {
+      result = new Result.fromJson(_json["result"]);
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (args != null) {
+      _json["args"] = args.map((value) => (value).toJson()).toList();
+    }
+    if (function != null) {
+      _json["function"] = function;
+    }
+    if (result != null) {
+      _json["result"] = (result).toJson();
+    }
+    return _json;
+  }
+}
+
 /** Issues include warnings, errors, and deprecation notices. */
 class Issue {
   /** Short error description. */
   core.String description;
   /**
    * The severity of the issue.
    * Possible string values are:
    * - "SEVERITY_UNSPECIFIED" : An unspecified severity.
    * - "DEPRECATION" : Deprecation issue for statements and method that may no
    * longer be
@@ skipping 13 matching lines @@
       description = _json["description"];
     }
     if (_json.containsKey("severity")) {
       severity = _json["severity"];
     }
     if (_json.containsKey("sourcePosition")) {
       sourcePosition = new SourcePosition.fromJson(_json["sourcePosition"]);
     }
   }
 
-  core.Map toJson() {
-    var _json = new core.Map();
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (description != null) {
       _json["description"] = description;
     }
     if (severity != null) {
       _json["severity"] = severity;
     }
     if (sourcePosition != null) {
       _json["sourcePosition"] = (sourcePosition).toJson();
     }
     return _json;
@@ skipping 14 matching lines @@
 
   ListReleasesResponse.fromJson(core.Map _json) {
     if (_json.containsKey("nextPageToken")) {
       nextPageToken = _json["nextPageToken"];
     }
     if (_json.containsKey("releases")) {
       releases = _json["releases"].map((value) => new Release.fromJson(value)).toList();
     }
   }
 
-  core.Map toJson() {
-    var _json = new core.Map();
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (nextPageToken != null) {
       _json["nextPageToken"] = nextPageToken;
     }
     if (releases != null) {
       _json["releases"] = releases.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
@@ skipping 11 matching lines @@
 
   ListRulesetsResponse.fromJson(core.Map _json) {
     if (_json.containsKey("nextPageToken")) {
       nextPageToken = _json["nextPageToken"];
     }
     if (_json.containsKey("rulesets")) {
       rulesets = _json["rulesets"].map((value) => new Ruleset.fromJson(value)).toList();
     }
   }
 
-  core.Map toJson() {
-    var _json = new core.Map();
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (nextPageToken != null) {
       _json["nextPageToken"] = nextPageToken;
     }
     if (rulesets != null) {
       _json["rulesets"] = rulesets.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
@@ skipping 55 matching lines @@
       name = _json["name"];
     }
     if (_json.containsKey("rulesetName")) {
       rulesetName = _json["rulesetName"];
     }
     if (_json.containsKey("updateTime")) {
       updateTime = _json["updateTime"];
     }
   }
 
-  core.Map toJson() {
-    var _json = new core.Map();
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (createTime != null) {
       _json["createTime"] = createTime;
     }
     if (name != null) {
       _json["name"] = name;
     }
     if (rulesetName != null) {
       _json["rulesetName"] = rulesetName;
     }
     if (updateTime != null) {
       _json["updateTime"] = updateTime;
     }
     return _json;
   }
 }
 
+/** Possible result values from the function mock invocation. */
+class Result {
+  /** The result is undefined, meaning the result could not be computed. */
+  Empty undefined;
+  /**
+   * The result is an actual value. The type of the value must match that
+   * of the type declared by the service.
+   *
+   * 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 value;
+
+  Result();
+
+  Result.fromJson(core.Map _json) {
+    if (_json.containsKey("undefined")) {
+      undefined = new Empty.fromJson(_json["undefined"]);
+    }
+    if (_json.containsKey("value")) {
+      value = _json["value"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (undefined != null) {
+      _json["undefined"] = (undefined).toJson();
+    }
+    if (value != null) {
+      _json["value"] = value;
+    }
+    return _json;
+  }
+}
+
 /**
  * `Ruleset` is an immutable copy of `Source` with a globally unique identifier
  * and a creation time.
  */
 class Ruleset {
   /**
    * Time the `Ruleset` was created.
    * Output only.
    */
   core.String createTime;
@@ skipping 13 matching lines @@
       createTime = _json["createTime"];
     }
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
     if (_json.containsKey("source")) {
       source = new Source.fromJson(_json["source"]);
     }
   }
 
-  core.Map toJson() {
-    var _json = new core.Map();
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (createTime != null) {
       _json["createTime"] = createTime;
     }
     if (name != null) {
       _json["name"] = name;
     }
     if (source != null) {
       _json["source"] = (source).toJson();
     }
     return _json;
   }
 }
 
 /**
  * `Source` is one or more `File` messages comprising a logical set of rules.
  */
 class Source {
   /** `File` set constituting the `Source` bundle. */
   core.List<File> files;
 
   Source();
 
   Source.fromJson(core.Map _json) {
     if (_json.containsKey("files")) {
       files = _json["files"].map((value) => new File.fromJson(value)).toList();
     }
   }
 
-  core.Map toJson() {
-    var _json = new core.Map();
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (files != null) {
       _json["files"] = files.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /**
  * Position in the `Source` content including its line, column number, and an
  * index of the `File` in the `Source` message. Used for debug purposes.
@@ skipping 13 matching lines @@
       column = _json["column"];
     }
     if (_json.containsKey("fileName")) {
       fileName = _json["fileName"];
     }
     if (_json.containsKey("line")) {
       line = _json["line"];
     }
   }
 
-  core.Map toJson() {
-    var _json = new core.Map();
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (column != null) {
       _json["column"] = column;
     }
     if (fileName != null) {
       _json["fileName"] = fileName;
     }
     if (line != null) {
       _json["line"] = line;
     }
     return _json;
   }
 }
 
 /**
+ * `TestCase` messages provide the request context and an expectation as to
+ * whether the given context will be allowed or denied. Test cases may specify
+ * the `request`, `resource`, and `function_mocks` to mock a function call to
+ * a service-provided function.
+ *
+ * The `request` object represents context present at request-time.
+ *
+ * The `resource` is the value of the target resource as it appears in
+ * persistent storage before the request is executed.
+ */
+class TestCase {
+  /**
+   * Test expectation.
+   * Possible string values are:
+   * - "EXPECTATION_UNSPECIFIED" : Unspecified expectation.
+   * - "ALLOW" : Expect an allowed result.
+   * - "DENY" : Expect a denied result.
+   */
+  core.String expectation;
+  /**
+   * Optional function mocks for service-defined functions. If not set, any
+   * service defined function is expected to return an error, which may or may
+   * not influence the test outcome.
+   */
+  core.List<FunctionMock> functionMocks;
+  /**
+   * Request context.
+   *
+   * The exact format of the request context is service-dependent. See the
+   * appropriate service documentation for information about the supported
+   * fields and types on the request. Minimally, all services support the
+   * following fields and types:
+   *
+   * Request field  | Type
+   * ---------------|-----------------
+   * auth.uid       | `string`
+   * auth.token     | `map<string, string>`
+   * headers        | `map<string, string>`
+   * method         | `string`
+   * params         | `map<string, string>`
+   * path           | `string`
+   * time           | `google.protobuf.Timestamp`
+   *
+   * If the request value is not well-formed for the service, the request will
+   * be rejected as an invalid argument.
+   *
+   * 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 request;
+  /**
+   * Optional resource value as it appears in persistent storage before the
+   * request is fulfilled.
+   *
+   * The resource type depends on the `request.path` value.
+   *
+   * 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 resource;
+
+  TestCase();
+
+  TestCase.fromJson(core.Map _json) {
+    if (_json.containsKey("expectation")) {
+      expectation = _json["expectation"];
+    }
+    if (_json.containsKey("functionMocks")) {
+      functionMocks = _json["functionMocks"].map((value) => new FunctionMock.fromJson(value)).toList();
+    }
+    if (_json.containsKey("request")) {
+      request = _json["request"];
+    }
+    if (_json.containsKey("resource")) {
+      resource = _json["resource"];
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (expectation != null) {
+      _json["expectation"] = expectation;
+    }
+    if (functionMocks != null) {
+      _json["functionMocks"] = functionMocks.map((value) => (value).toJson()).toList();
+    }
+    if (request != null) {
+      _json["request"] = request;
+    }
+    if (resource != null) {
+      _json["resource"] = resource;
+    }
+    return _json;
+  }
+}
+
+/**
  * Test result message containing the state of the test as well as a
  * description and source position for test failures.
  */
 class TestResult {
   /**
    * Debug messages related to test execution issues encountered during
    * evaluation.
    *
    * Debug messages may be related to too many or too few invocations of
    * function mocks or to runtime errors that occur during evaluation.
@@ skipping 39 matching lines @@
       errorPosition = new SourcePosition.fromJson(_json["errorPosition"]);
     }
     if (_json.containsKey("functionCalls")) {
       functionCalls = _json["functionCalls"].map((value) => new FunctionCall.fromJson(value)).toList();
     }
     if (_json.containsKey("state")) {
       state = _json["state"];
     }
   }
 
-  core.Map toJson() {
-    var _json = new core.Map();
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (debugMessages != null) {
       _json["debugMessages"] = debugMessages;
     }
     if (errorPosition != null) {
       _json["errorPosition"] = (errorPosition).toJson();
     }
     if (functionCalls != null) {
       _json["functionCalls"] = functionCalls.map((value) => (value).toJson()).toList();
     }
     if (state != null) {
       _json["state"] = state;
     }
     return _json;
   }
 }
 
 /** The request for FirebaseRulesService.TestRuleset. */
 class TestRulesetRequest {
   /**
    * Optional `Source` to be checked for correctness.
    *
    * This field must not be set when the resource name refers to a `Ruleset`.
    */
   Source source;
+  /** Inline `TestSuite` to run. */
+  TestSuite testSuite;
 
   TestRulesetRequest();
 
   TestRulesetRequest.fromJson(core.Map _json) {
     if (_json.containsKey("source")) {
       source = new Source.fromJson(_json["source"]);
     }
+    if (_json.containsKey("testSuite")) {
+      testSuite = new TestSuite.fromJson(_json["testSuite"]);
+    }
   }
 
-  core.Map toJson() {
-    var _json = new core.Map();
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (source != null) {
       _json["source"] = (source).toJson();
     }
+    if (testSuite != null) {
+      _json["testSuite"] = (testSuite).toJson();
+    }
     return _json;
   }
 }
 
 /** The response for FirebaseRulesService.TestRuleset. */
 class TestRulesetResponse {
   /**
    * Syntactic and semantic `Source` issues of varying severity. Issues of
    * `ERROR` severity will prevent tests from executing.
    */
   core.List<Issue> issues;
   /**
    * The set of test results given the test cases in the `TestSuite`.
    * The results will appear in the same order as the test cases appear in the
    * `TestSuite`.
    */
   core.List<TestResult> testResults;
 
   TestRulesetResponse();
 
   TestRulesetResponse.fromJson(core.Map _json) {
     if (_json.containsKey("issues")) {
       issues = _json["issues"].map((value) => new Issue.fromJson(value)).toList();
     }
     if (_json.containsKey("testResults")) {
       testResults = _json["testResults"].map((value) => new TestResult.fromJson(value)).toList();
     }
   }
 
-  core.Map toJson() {
-    var _json = new core.Map();
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
     if (issues != null) {
       _json["issues"] = issues.map((value) => (value).toJson()).toList();
     }
     if (testResults != null) {
       _json["testResults"] = testResults.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
+
+/**
+ * `TestSuite` is a collection of `TestCase` instances that validate the logical
+ * correctness of a `Ruleset`. The `TestSuite` may be referenced in-line within
+ * a `TestRuleset` invocation or as part of a `Release` object as a pre-release
+ * check.
+ */
+class TestSuite {
+  /** Collection of test cases associated with the `TestSuite`. */
+  core.List<TestCase> testCases;
+
+  TestSuite();
+
+  TestSuite.fromJson(core.Map _json) {
+    if (_json.containsKey("testCases")) {
+      testCases = _json["testCases"].map((value) => new TestCase.fromJson(value)).toList();
+    }
+  }
+
+  core.Map<core.String, core.Object> toJson() {
+    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    if (testCases != null) {
+      _json["testCases"] = testCases.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}