Api-roll 48: 2017-04-18

generated/googleapis/lib/serviceuser/v1.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis.serviceuser.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_1;
@@ skipping 1219 matching lines @@
    * the browser to determine whether the subsequent cross-origin request is
    * allowed to proceed.
    */
   core.bool allowCors;
   /** The list of APIs served by this endpoint. */
   core.List<core.String> apis;
   /** The list of features enabled on this endpoint. */
   core.List<core.String> features;
   /** The canonical name of this endpoint. */
   core.String name;
+  /**
+   * The specification of an Internet routable address of API frontend that will
+   * handle requests to this [API
+   * Endpoint](https://cloud.google.com/apis/design/glossary).
+   * It should be either a valid IPv4 address or a fully-qualified domain name.
+   * For example, "8.8.8.8" or "myservice.appspot.com".
+   */
+  core.String target;
 
   Endpoint();
 
   Endpoint.fromJson(core.Map _json) {
     if (_json.containsKey("aliases")) {
       aliases = _json["aliases"];
     }
     if (_json.containsKey("allowCors")) {
       allowCors = _json["allowCors"];
     }
     if (_json.containsKey("apis")) {
       apis = _json["apis"];
     }
     if (_json.containsKey("features")) {
       features = _json["features"];
     }
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
+    if (_json.containsKey("target")) {
+      target = _json["target"];
+    }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (aliases != null) {
       _json["aliases"] = aliases;
     }
     if (allowCors != null) {
       _json["allowCors"] = allowCors;
     }
     if (apis != null) {
       _json["apis"] = apis;
     }
     if (features != null) {
       _json["features"] = features;
     }
     if (name != null) {
       _json["name"] = name;
     }
+    if (target != null) {
+      _json["target"] = target;
+    }
     return _json;
   }
 }
 
 /** Enum type definition. */
 class Enum {
   /** Enum value definitions. */
   core.List<EnumValue> enumvalue;
   /** Enum type name. */
   core.String name;
@@ skipping 244 matching lines @@
   }
 }
 
 /**
  * Defines the HTTP configuration for a service. It contains a list of
  * HttpRule, each specifying the mapping of an RPC method
  * to one or more HTTP REST API methods.
  */
 class Http {
   /**
+   * When set to true, URL path parmeters will be fully URI-decoded except in
+   * cases of single segment matches in reserved expansion, where "%2F" will be
+   * left encoded.
+   *
+   * The default behavior is to not decode RFC 6570 reserved characters in multi
+   * segment matches.
+   */
+  core.bool fullyDecodeReservedExpansion;
+  /**
    * A list of HTTP configuration rules that apply to individual API methods.
    *
    * **NOTE:** All service configuration rules follow "last one wins" order.
    */
   core.List<HttpRule> rules;
 
   Http();
 
   Http.fromJson(core.Map _json) {
+    if (_json.containsKey("fullyDecodeReservedExpansion")) {
+      fullyDecodeReservedExpansion = _json["fullyDecodeReservedExpansion"];
+    }
     if (_json.containsKey("rules")) {
       rules = _json["rules"].map((value) => new HttpRule.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
+    if (fullyDecodeReservedExpansion != null) {
+      _json["fullyDecodeReservedExpansion"] = fullyDecodeReservedExpansion;
+    }
     if (rules != null) {
       _json["rules"] = rules.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /**
  * `HttpRule` defines the mapping of an RPC method to one or more HTTP
  * REST APIs.  The mapping determines what portions of the request
@@ skipping 950 matching lines @@
       _json["unit"] = unit;
     }
     if (valueType != null) {
       _json["valueType"] = valueType;
     }
     return _json;
   }
 }
 
 /**
+ * Bind API methods to metrics. Binding a method to a metric causes that
+ * metric's configured quota, billing, and monitoring behaviors to apply to the
+ * method call.
+ *
+ * Used by metric-based quotas only.
+ */
+class MetricRule {
+  /**
+   * Metrics to update when the selected methods are called, and the associated
+   * cost applied to each metric.
+   *
+   * The key of the map is the metric name, and the values are the amount
+   * increased for the metric against which the quota limits are defined.
+   * The value must not be negative.
+   */
+  core.Map<core.String, core.String> metricCosts;
+  /**
+   * Selects the methods to which this rule applies.
+   *
+   * Refer to selector for syntax details.
+   */
+  core.String selector;
+
+  MetricRule();
+
+  MetricRule.fromJson(core.Map _json) {
+    if (_json.containsKey("metricCosts")) {
+      metricCosts = _json["metricCosts"];
+    }
+    if (_json.containsKey("selector")) {
+      selector = _json["selector"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (metricCosts != null) {
+      _json["metricCosts"] = metricCosts;
+    }
+    if (selector != null) {
+      _json["selector"] = selector;
+    }
+    return _json;
+  }
+}
+
+/**
  * Declares an API to be included in this API. The including API must
  * redeclare all the methods from the included API, but documentation
  * and options are inherited as follows:
  *
  * - If after comment and whitespace stripping, the documentation
  *   string of the redeclared method is empty, it will be inherited
  *   from the original method.
  *
  * - Each annotation belonging to the service config (http,
  *   visibility) which is not set in the redeclared method will be
@@ skipping 624 matching lines @@
     if (name != null) {
       _json["name"] = name;
     }
     if (service != null) {
       _json["service"] = (service).toJson();
     }
     return _json;
   }
 }
 
+/**
+ * Quota configuration helps to achieve fairness and budgeting in service
+ * usage.
+ *
+ * The quota configuration works this way:
+ * - The service configuration defines a set of metrics.
+ * - For API calls, the quota.metric_rules maps methods to metrics with
+ *   corresponding costs.
+ * - The quota.limits defines limits on the metrics, which will be used for
+ *   quota checks at runtime.
+ *
+ * An example quota configuration in yaml format:
+ *
+ *    quota:
+ *
+ *      - name: apiWriteQpsPerProject
+ *        metric: library.googleapis.com/write_calls
+ *        unit: "1/min/{project}"  # rate limit for consumer projects
+ *        values:
+ *          STANDARD: 10000
+ *
+ *
+ *      # The metric rules bind all methods to the read_calls metric,
+ *      # except for the UpdateBook and DeleteBook methods. These two methods
+ *      # are mapped to the write_calls metric, with the UpdateBook method
+ *      # consuming at twice rate as the DeleteBook method.
+ *      metric_rules:
+ *      - selector: "*"
+ *        metric_costs:
+ *          library.googleapis.com/read_calls: 1
+ *      - selector: google.example.library.v1.LibraryService.UpdateBook
+ *        metric_costs:
+ *          library.googleapis.com/write_calls: 2
+ *      - selector: google.example.library.v1.LibraryService.DeleteBook
+ *        metric_costs:
+ *          library.googleapis.com/write_calls: 1
+ *
+ *  Corresponding Metric definition:
+ *
+ *      metrics:
+ *      - name: library.googleapis.com/read_calls
+ *        display_name: Read requests
+ *        metric_kind: DELTA
+ *        value_type: INT64
+ *
+ *      - name: library.googleapis.com/write_calls
+ *        display_name: Write requests
+ *        metric_kind: DELTA
+ *        value_type: INT64
+ */
+class Quota {
+  /**
+   * List of `QuotaLimit` definitions for the service.
+   *
+   * Used by metric-based quotas only.
+   */
+  core.List<QuotaLimit> limits;
+  /**
+   * List of `MetricRule` definitions, each one mapping a selected method to one
+   * or more metrics.
+   *
+   * Used by metric-based quotas only.
+   */
+  core.List<MetricRule> metricRules;
+
+  Quota();
+
+  Quota.fromJson(core.Map _json) {
+    if (_json.containsKey("limits")) {
+      limits = _json["limits"].map((value) => new QuotaLimit.fromJson(value)).toList();
+    }
+    if (_json.containsKey("metricRules")) {
+      metricRules = _json["metricRules"].map((value) => new MetricRule.fromJson(value)).toList();
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (limits != null) {
+      _json["limits"] = limits.map((value) => (value).toJson()).toList();
+    }
+    if (metricRules != null) {
+      _json["metricRules"] = metricRules.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}
+
+/**
+ * `QuotaLimit` defines a specific limit that applies over a specified duration
+ * for a limit type. There can be at most one limit for a duration and limit
+ * type combination defined within a `QuotaGroup`.
+ */
+class QuotaLimit {
+  /**
+   * Default number of tokens that can be consumed during the specified
+   * duration. This is the number of tokens assigned when a client
+   * application developer activates the service for his/her project.
+   *
+   * Specifying a value of 0 will block all requests. This can be used if you
+   * are provisioning quota to selected consumers and blocking others.
+   * Similarly, a value of -1 will indicate an unlimited quota. No other
+   * negative values are allowed.
+   *
+   * Used by group-based quotas only.
+   */
+  core.String defaultLimit;
+  /**
+   * Optional. User-visible, extended description for this quota limit.
+   * Should be used only when more context is needed to understand this limit
+   * than provided by the limit's display name (see: `display_name`).
+   */
+  core.String description;
+  /**
+   * User-visible display name for this limit.
+   * Optional. If not set, the UI will provide a default display name based on
+   * the quota configuration. This field can be used to override the default
+   * display name generated from the configuration.
+   */
+  core.String displayName;
+  /**
+   * Duration of this limit in textual notation. Example: "100s", "24h", "1d".
+   * For duration longer than a day, only multiple of days is supported. We
+   * support only "100s" and "1d" for now. Additional support will be added in
+   * the future. "0" indicates indefinite duration.
+   *
+   * Used by group-based quotas only.
+   */
+  core.String duration;
+  /**
+   * Free tier value displayed in the Developers Console for this limit.
+   * The free tier is the number of tokens that will be subtracted from the
+   * billed amount when billing is enabled.
+   * This field can only be set on a limit with duration "1d", in a billable
+   * group; it is invalid on any other limit. If this field is not set, it
+   * defaults to 0, indicating that there is no free tier for this service.
+   *
+   * Used by group-based quotas only.
+   */
+  core.String freeTier;
+  /**
+   * Maximum number of tokens that can be consumed during the specified
+   * duration. Client application developers can override the default limit up
+   * to this maximum. If specified, this value cannot be set to a value less
+   * than the default limit. If not specified, it is set to the default limit.
+   *
+   * To allow clients to apply overrides with no upper bound, set this to -1,
+   * indicating unlimited maximum quota.
+   *
+   * Used by group-based quotas only.
+   */
+  core.String maxLimit;
+  /**
+   * The name of the metric this quota limit applies to. The quota limits with
+   * the same metric will be checked together during runtime. The metric must be
+   * defined within the service config.
+   *
+   * Used by metric-based quotas only.
+   */
+  core.String metric;
+  /**
+   * Name of the quota limit. The name is used to refer to the limit when
+   * overriding the default limit on per-consumer basis.
+   *
+   * For group-based quota limits, the name must be unique within the quota
+   * group. If a name is not provided, it will be generated from the limit_by
+   * and duration fields.
+   *
+   * For metric-based quota limits, the name must be provided, and it must be
+   * unique within the service. The name can only include alphanumeric
+   * characters as well as '-'.
+   *
+   * The maximum length of the limit name is 64 characters.
+   *
+   * The name of a limit is used as a unique identifier for this limit.
+   * Therefore, once a limit has been put into use, its name should be
+   * immutable. You can use the display_name field to provide a user-friendly
+   * name for the limit. The display name can be evolved over time without
+   * affecting the identity of the limit.
+   */
+  core.String name;
+  /**
+   * Specify the unit of the quota limit. It uses the same syntax as
+   * Metric.unit. The supported unit kinds are determined by the quota
+   * backend system.
+   *
+   * The [Google Service Control](https://cloud.google.com/service-control)
+   * supports the following unit components:
+   * * One of the time intevals:
+   *   * "/min"  for quota every minute.
+   *   * "/d"  for quota every 24 hours, starting 00:00 US Pacific Time.
+   *   * Otherwise the quota won't be reset by time, such as storage limit.
+   * * One and only one of the granted containers:
+   *   * "/{organization}" quota for an organization.
+   *   * "/{project}" quota for a project.
+   *   * "/{folder}" quota for a folder.
+   *   * "/{resource}" quota for a universal resource.
+   * * Zero or more quota segmentation dimension. Not all combos are valid.
+   * * "/{region}" quota for every region. Not to be used with time intervals.
+   *   * Otherwise the resources granted on the target is not segmented.
+   *   * "/{zone}" quota for every zone. Not to be used with time intervals.
+   *   * Otherwise the resources granted on the target is not segmented.
+   *   * "/{resource}" quota for a resource associated with a project or org.
+   *
+   * Here are some examples:
+   * * "1/min/{project}" for quota per minute per project.
+   * * "1/min/{user}" for quota per minute per user.
+   * * "1/min/{organization}" for quota per minute per organization.
+   *
+   * Note: the order of unit components is insignificant.
+   * The "1" at the beginning is required to follow the metric unit syntax.
+   *
+   * Used by metric-based quotas only.
+   */
+  core.String unit;
+  /**
+   * Tiered limit values. Also allows for regional or zone overrides for these
+   * values if "/{region}" or "/{zone}" is specified in the unit field.
+   *
+   * Currently supported tiers from low to high:
+   * VERY_LOW, LOW, STANDARD, HIGH, VERY_HIGH
+   *
+   * To apply different limit values for users according to their tiers, specify
+   * the values for the tiers you want to differentiate. For example:
+   * {LOW:100, STANDARD:500, HIGH:1000, VERY_HIGH:5000}
+   *
+   * The limit value for each tier is optional except for the tier STANDARD.
+   * The limit value for an unspecified tier falls to the value of its next
+   * tier towards tier STANDARD. For the above example, the limit value for tier
+   * STANDARD is 500.
+   *
+   * To apply the same limit value for all users, just specify limit value for
+   * tier STANDARD. For example: {STANDARD:500}.
+   *
+   * To apply a regional overide for a tier, add a map entry with key
+   * "<TIER>/<region>", where <region> is a region name. Similarly, for a zone
+   * override, add a map entry with key "<TIER>/{zone}".
+   * Further, a wildcard can be used at the end of a zone name in order to
+   * specify zone level overrides. For example:
+   * LOW: 10, STANDARD: 50, HIGH: 100,
+   * LOW/us-central1: 20, STANDARD/us-central1: 60, HIGH/us-central1: 200,
+   * LOW/us-central1-*: 10, STANDARD/us-central1-*: 20, HIGH/us-central1-*: 80
+   *
+   * The regional overrides tier set for each region must be the same as
+   * the tier set for default limit values. Same rule applies for zone overrides
+   * tier as well.
+   *
+   * Used by metric-based quotas only.
+   */
+  core.Map<core.String, core.String> values;
+
+  QuotaLimit();
+
+  QuotaLimit.fromJson(core.Map _json) {
+    if (_json.containsKey("defaultLimit")) {
+      defaultLimit = _json["defaultLimit"];
+    }
+    if (_json.containsKey("description")) {
+      description = _json["description"];
+    }
+    if (_json.containsKey("displayName")) {
+      displayName = _json["displayName"];
+    }
+    if (_json.containsKey("duration")) {
+      duration = _json["duration"];
+    }
+    if (_json.containsKey("freeTier")) {
+      freeTier = _json["freeTier"];
+    }
+    if (_json.containsKey("maxLimit")) {
+      maxLimit = _json["maxLimit"];
+    }
+    if (_json.containsKey("metric")) {
+      metric = _json["metric"];
+    }
+    if (_json.containsKey("name")) {
+      name = _json["name"];
+    }
+    if (_json.containsKey("unit")) {
+      unit = _json["unit"];
+    }
+    if (_json.containsKey("values")) {
+      values = _json["values"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (defaultLimit != null) {
+      _json["defaultLimit"] = defaultLimit;
+    }
+    if (description != null) {
+      _json["description"] = description;
+    }
+    if (displayName != null) {
+      _json["displayName"] = displayName;
+    }
+    if (duration != null) {
+      _json["duration"] = duration;
+    }
+    if (freeTier != null) {
+      _json["freeTier"] = freeTier;
+    }
+    if (maxLimit != null) {
+      _json["maxLimit"] = maxLimit;
+    }
+    if (metric != null) {
+      _json["metric"] = metric;
+    }
+    if (name != null) {
+      _json["name"] = name;
+    }
+    if (unit != null) {
+      _json["unit"] = unit;
+    }
+    if (values != null) {
+      _json["values"] = values;
+    }
+    return _json;
+  }
+}
+
 /** Response message for SearchServices method. */
 class SearchServicesResponse {
   /**
    * Token that can be passed to `ListAvailableServices` to resume a paginated
    * query.
    */
   core.String nextPageToken;
   /** Services available publicly or available to the authenticated caller. */
   core.List<PublishedService> services;
 
@@ skipping 116 matching lines @@
    * The DNS address at which this service is available,
    * e.g. `calendar.googleapis.com`.
    */
   core.String name;
   /**
    * The id of the Google developer project that owns the service.
    * Members of this project can manage the service configuration,
    * manage consumption of the service, etc.
    */
   core.String producerProjectId;
+  /** Quota configuration. */
+  Quota quota;
   /**
    * Output only. The source information for this configuration if available.
    */
   SourceInfo sourceInfo;
   /** System parameter configuration. */
   SystemParameters systemParameters;
   /**
    * A list of all proto message types included in this API service.
    * It serves similar purpose as [google.api.Service.types], except that
    * these types are not needed by user-defined APIs. Therefore, they will not
@@ skipping 75 matching lines @@
     }
     if (_json.containsKey("monitoring")) {
       monitoring = new Monitoring.fromJson(_json["monitoring"]);
     }
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
     if (_json.containsKey("producerProjectId")) {
       producerProjectId = _json["producerProjectId"];
     }
+    if (_json.containsKey("quota")) {
+      quota = new Quota.fromJson(_json["quota"]);
+    }
     if (_json.containsKey("sourceInfo")) {
       sourceInfo = new SourceInfo.fromJson(_json["sourceInfo"]);
     }
     if (_json.containsKey("systemParameters")) {
       systemParameters = new SystemParameters.fromJson(_json["systemParameters"]);
     }
     if (_json.containsKey("systemTypes")) {
       systemTypes = _json["systemTypes"].map((value) => new Type.fromJson(value)).toList();
     }
     if (_json.containsKey("title")) {
@@ skipping 65 matching lines @@
     }
     if (monitoring != null) {
       _json["monitoring"] = (monitoring).toJson();
     }
     if (name != null) {
       _json["name"] = name;
     }
     if (producerProjectId != null) {
       _json["producerProjectId"] = producerProjectId;
     }
+    if (quota != null) {
+      _json["quota"] = (quota).toJson();
+    }
     if (sourceInfo != null) {
       _json["sourceInfo"] = (sourceInfo).toJson();
     }
     if (systemParameters != null) {
       _json["systemParameters"] = (systemParameters).toJson();
     }
     if (systemTypes != null) {
       _json["systemTypes"] = systemTypes.map((value) => (value).toJson()).toList();
     }
     if (title != null) {
@@ skipping 639 matching lines @@
     var _json = new core.Map();
     if (restriction != null) {
       _json["restriction"] = restriction;
     }
     if (selector != null) {
       _json["selector"] = selector;
     }
     return _json;
   }
 }