Api-roll 43: 2016-12-13

generated/googleapis/lib/servicemanagement/v1.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis.servicemanagement.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 128 matching lines @@
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Operation.fromJson(data));
   }
 
   /**
-   * Deletes a managed service. This method will change the serivce in the
+   * Deletes a managed service. This method will change the service to the
    * `Soft-Delete` state for 30 days. Within this period, service producers may
    * call UndeleteService to restore the service.
    * After 30 days, the service will be permanently deleted.
    *
    * Operation<response: google.protobuf.Empty>
    *
    * Request parameters:
    *
    * [serviceName] - The name of the service.  See the
    * [overview](/service-management/overview)
@@ skipping 326 matching lines @@
    * Request parameters:
    *
    * [pageSize] - Requested size of the next page of data.
    *
    * [producerProjectId] - Include services produced by the specified project.
    *
    * [pageToken] - Token identifying which result to start with; returned by a
    * previous list
    * call.
    *
+   * [consumerId] - Include services consumed by the specified consumer.
+   *
+   * The Google Service Management implementation accepts the following
+   * forms:
+   * - project:<project_id>
+   *
    * Completes with a [ListServicesResponse].
    *
    * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http_1.Client] completes with an error when making a REST
    * call, this method will complete with the same error.
    */
-  async.Future<ListServicesResponse> list({core.int pageSize, core.String producerProjectId, core.String pageToken}) {
+  async.Future<ListServicesResponse> list({core.int pageSize, core.String producerProjectId, core.String pageToken, core.String consumerId}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (pageSize != null) {
       _queryParams["pageSize"] = ["${pageSize}"];
     }
     if (producerProjectId != null) {
       _queryParams["producerProjectId"] = [producerProjectId];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
+    if (consumerId != null) {
+      _queryParams["consumerId"] = [consumerId];
+    }
 
     _url = 'v1/services';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 44 matching lines @@
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Policy.fromJson(data));
   }
 
   /**
    * Returns permissions that a caller has on the specified resource.
+   * If the resource does not exist, this will return an empty set of
+   * permissions, not a NOT_FOUND error.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [resource] - REQUIRED: The resource for which the policy detail is being
    * requested.
    * `resource` is usually specified as a path. For example, a Project
    * resource is specified as `projects/{project}`.
    * Value must have pattern "^services/[^/]+$".
@@ skipping 579 matching lines @@
       _json["syntax"] = syntax;
     }
     if (version != null) {
       _json["version"] = version;
     }
     return _json;
   }
 }
 
 /**
- * Enables "data access" audit logging for a service and specifies a list
- * of members that are log-exempted.
+ * Provides the configuration for non-admin_activity logging for a service.
+ * Controls exemptions and specific log sub-types.
  */
 class AuditConfig {
   /**
+   * The configuration for each type of logging
+   * Next ID: 4
+   */
+  core.List<AuditLogConfig> auditLogConfigs;
+  /**
    * Specifies the identities that are exempted from "data access" audit
    * logging for the `service` specified above.
    * Follows the same format of Binding.members.
    */
   core.List<core.String> exemptedMembers;
   /**
-   * Specifies a service that will be enabled for "data access" audit
-   * logging.
+   * Specifies a service that will be enabled for audit logging.
    * For example, `resourcemanager`, `storage`, `compute`.
    * `allServices` is a special value that covers all services.
    */
   core.String service;
 
   AuditConfig();
 
   AuditConfig.fromJson(core.Map _json) {
+    if (_json.containsKey("auditLogConfigs")) {
+      auditLogConfigs = _json["auditLogConfigs"].map((value) => new AuditLogConfig.fromJson(value)).toList();
+    }
     if (_json.containsKey("exemptedMembers")) {
       exemptedMembers = _json["exemptedMembers"];
     }
     if (_json.containsKey("service")) {
       service = _json["service"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
+    if (auditLogConfigs != null) {
+      _json["auditLogConfigs"] = auditLogConfigs.map((value) => (value).toJson()).toList();
+    }
     if (exemptedMembers != null) {
       _json["exemptedMembers"] = exemptedMembers;
     }
     if (service != null) {
       _json["service"] = service;
     }
     return _json;
   }
 }
 
+/** Provides the configuration for a sub-type of logging. */
+class AuditLogConfig {
+  /**
+   * Specifies the identities that are exempted from this type of logging
+   * Follows the same format of Binding.members.
+   */
+  core.List<core.String> exemptedMembers;
+  /**
+   * The log type that this config enables.
+   * Possible string values are:
+   * - "LOG_TYPE_UNSPECIFIED" : Default case. Should never be this.
+   * - "ADMIN_READ" : Log admin reads
+   * - "DATA_WRITE" : Log data writes
+   * - "DATA_READ" : Log data reads
+   */
+  core.String logType;
+
+  AuditLogConfig();
+
+  AuditLogConfig.fromJson(core.Map _json) {
+    if (_json.containsKey("exemptedMembers")) {
+      exemptedMembers = _json["exemptedMembers"];
+    }
+    if (_json.containsKey("logType")) {
+      logType = _json["logType"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (exemptedMembers != null) {
+      _json["exemptedMembers"] = exemptedMembers;
+    }
+    if (logType != null) {
+      _json["logType"] = logType;
+    }
+    return _json;
+  }
+}
+
 /**
  * Configuration for an anthentication provider, including support for
  * [JSON Web Token
  * (JWT)](https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32).
  */
 class AuthProvider {
   /**
    * The list of JWT
    * [audiences](https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32#section-4.1.3).
    * that are allowed to access. A JWT containing any of these audiences will
@@ skipping 133 matching lines @@
   }
 }
 
 /**
  * `Authentication` defines the authentication configuration for an API.
  *
  * Example for an API targeted for external use:
  *
  *     name: calendar.googleapis.com
  *     authentication:
+ *       providers:
+ *       - id: google_calendar_auth
+ *         jwks_uri: https://www.googleapis.com/oauth2/v1/certs
+ *         issuer: https://securetoken.google.com
  *       rules:
  *       - selector: "*"
- *         oauth:
- *           canonical_scopes: https://www.googleapis.com/auth/calendar
- *
- *       - selector: google.calendar.Delegate
- *         oauth:
- *           canonical_scopes: https://www.googleapis.com/auth/calendar.read
+ *         requirements:
+ *           provider_id: google_calendar_auth
  */
 class Authentication {
   /** Defines a set of authentication providers that a service supports. */
   core.List<AuthProvider> providers;
   /**
    * A list of authentication rules that apply to individual API methods.
    *
    * **NOTE:** All service configuration rules follow "last one wins" order.
    */
   core.List<AuthenticationRule> rules;
@@ skipping 1160 matching lines @@
  * Example service configuration:
  *
  *     name: library-example.googleapis.com
  *     endpoints:
  *       # Below entry makes 'google.example.library.v1.Library'
  *       # API be served from endpoint address library-example.googleapis.com.
  *       # It also allows HTTP OPTIONS calls to be passed to the backend, for
  *       # it to decide whether the subsequent cross-origin request is
  *       # allowed to proceed.
  *     - name: library-example.googleapis.com
- *       apis: google.example.library.v1.Library
  *       allow_cors: true
- *       # Below entry makes 'google.example.library.v1.Library'
- *       # API be served from endpoint address
- *       # google.example.library-example.v1.LibraryManager.
- *     - name: library-manager.googleapis.com
- *       apis: google.example.library.v1.LibraryManager
- *       # BNS address for a borg job. Can specify a task by appending
- *       # "/taskId" (e.g. "/0") to the job spec.
- *
- * Example OpenAPI extension for endpoint with allow_cors set to true:
- *
- *     {
- *       "swagger": "2.0",
- *       "info": {
- *         "description": "A simple..."
- *       },
- *       "host": "MY_PROJECT_ID.appspot.com",
- *       "x-google-endpoints": [{
- *         "name": "MY_PROJECT_ID.appspot.com",
- *         "allow_cors": "true"
- *       }]
- *     }
  */
 class Endpoint {
   /**
    * DEPRECATED: This field is no longer supported. Instead of using aliases,
    * please specify multiple google.api.Endpoint for each of the intented
    * alias.
    *
    * Additional names that this endpoint will be hosted on.
    */
   core.List<core.String> aliases;
@@ skipping 433 matching lines @@
  * message are populated from the path, query parameters, or body of
  * the HTTP request.  The mapping is typically specified as an
  * `google.api.http` annotation, see "google/api/annotations.proto"
  * for details.
  *
  * The mapping consists of a field specifying the path template and
  * method kind.  The path template can refer to fields in the request
  * message, as in the example below which describes a REST GET
  * operation on a resource collection of messages:
  *
- * ```proto
- * service Messaging {
- *   rpc GetMessage(GetMessageRequest) returns (Message) {
+ *
+ *     service Messaging {
+ *       rpc GetMessage(GetMessageRequest) returns (Message) {
  * option (google.api.http).get = "/v1/messages/{message_id}/{sub.subfield}";
- *   }
- * }
- * message GetMessageRequest {
- *   message SubMessage {
- *     string subfield = 1;
- *   }
- *   string message_id = 1; // mapped to the URL
- *   SubMessage sub = 2;    // `sub.subfield` is url-mapped
- * }
- * message Message {
- *   string text = 1; // content of the resource
- * }
- * ```
+ *       }
+ *     }
+ *     message GetMessageRequest {
+ *       message SubMessage {
+ *         string subfield = 1;
+ *       }
+ *       string message_id = 1; // mapped to the URL
+ *       SubMessage sub = 2;    // `sub.subfield` is url-mapped
+ *     }
+ *     message Message {
+ *       string text = 1; // content of the resource
+ *     }
+ *
+ * The same http annotation can alternatively be expressed inside the
+ * `GRPC API Configuration` YAML file.
+ *
+ *     http:
+ *       rules:
+ *         - selector: <proto_package_name>.Messaging.GetMessage
+ *           get: /v1/messages/{message_id}/{sub.subfield}
  *
  * This definition enables an automatic, bidrectional mapping of HTTP
  * JSON to RPC. Example:
  *
  * HTTP | RPC
  * -----|-----
  * `GET /v1/messages/123456/foo`  | `GetMessage(message_id: "123456" sub:
  * SubMessage(subfield: "foo"))`
  *
  * In general, not only fields but also field paths can be referenced
  * from a path pattern. Fields mapped to the path pattern cannot be
  * repeated and must have a primitive (non-message) type.
  *
  * Any fields in the request message which are not bound by the path
  * pattern automatically become (optional) HTTP query
  * parameters. Assume the following definition of the request message:
  *
- * ```proto
- * message GetMessageRequest {
- *   message SubMessage {
- *     string subfield = 1;
- *   }
- *   string message_id = 1; // mapped to the URL
- *   int64 revision = 2;    // becomes a parameter
- *   SubMessage sub = 3;    // `sub.subfield` becomes a parameter
- * }
- * ```
+ *
+ *     message GetMessageRequest {
+ *       message SubMessage {
+ *         string subfield = 1;
+ *       }
+ *       string message_id = 1; // mapped to the URL
+ *       int64 revision = 2;    // becomes a parameter
+ *       SubMessage sub = 3;    // `sub.subfield` becomes a parameter
+ *     }
+ *
  *
  * This enables a HTTP JSON to RPC mapping as below:
  *
  * HTTP | RPC
  * -----|-----
  * `GET /v1/messages/123456?revision=2&sub.subfield=foo` |
  * `GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield:
  * "foo"))`
  *
  * Note that fields which are mapped to HTTP parameters must have a
  * primitive type or a repeated primitive type. Message types are not
  * allowed. In the case of a repeated type, the parameter can be
  * repeated in the URL, as in `...?param=A&param=B`.
  *
  * For HTTP method kinds which allow a request body, the `body` field
  * specifies the mapping. Consider a REST update method on the
  * message resource collection:
  *
- * ```proto
- * service Messaging {
- *   rpc UpdateMessage(UpdateMessageRequest) returns (Message) {
- *     option (google.api.http) = {
- *       put: "/v1/messages/{message_id}"
- *       body: "message"
- *     };
- *   }
- * }
- * message UpdateMessageRequest {
- *   string message_id = 1; // mapped to the URL
- *   Message message = 2;   // mapped to the body
- * }
- * ```
+ *
+ *     service Messaging {
+ *       rpc UpdateMessage(UpdateMessageRequest) returns (Message) {
+ *         option (google.api.http) = {
+ *           put: "/v1/messages/{message_id}"
+ *           body: "message"
+ *         };
+ *       }
+ *     }
+ *     message UpdateMessageRequest {
+ *       string message_id = 1; // mapped to the URL
+ *       Message message = 2;   // mapped to the body
+ *     }
+ *
  *
  * The following HTTP JSON to RPC mapping is enabled, where the
  * representation of the JSON in the request body is determined by
  * protos JSON encoding:
  *
  * HTTP | RPC
  * -----|-----
  * `PUT /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id:
  * "123456" message { text: "Hi!" })`
  *
  * The special name `*` can be used in the body mapping to define that
  * every field not bound by the path template should be mapped to the
  * request body.  This enables the following alternative definition of
  * the update method:
  *
- * ```proto
- * service Messaging {
- *   rpc UpdateMessage(Message) returns (Message) {
- *     option (google.api.http) = {
- *       put: "/v1/messages/{message_id}"
- *       body: "*"
- *     };
- *   }
- * }
- * message Message {
- *   string message_id = 1;
- *   string text = 2;
- * }
- * ```
+ *     service Messaging {
+ *       rpc UpdateMessage(Message) returns (Message) {
+ *         option (google.api.http) = {
+ *           put: "/v1/messages/{message_id}"
+ *           body: "*"
+ *         };
+ *       }
+ *     }
+ *     message Message {
+ *       string message_id = 1;
+ *       string text = 2;
+ *     }
+ *
  *
  * The following HTTP JSON to RPC mapping is enabled:
  *
  * HTTP | RPC
  * -----|-----
  * `PUT /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id:
  * "123456" text: "Hi!")`
  *
  * Note that when using `*` in the body mapping, it is not possible to
  * have HTTP parameters, as all fields not bound by the path end in
  * the body. This makes this option more rarely used in practice of
  * defining REST APIs. The common usage of `*` is in custom methods
  * which don't use the URL at all for transferring data.
  *
  * It is possible to define multiple HTTP methods for one RPC by using
  * the `additional_bindings` option. Example:
  *
- * ```proto
- * service Messaging {
- *   rpc GetMessage(GetMessageRequest) returns (Message) {
- *     option (google.api.http) = {
- *       get: "/v1/messages/{message_id}"
- *       additional_bindings {
- *         get: "/v1/users/{user_id}/messages/{message_id}"
+ *     service Messaging {
+ *       rpc GetMessage(GetMessageRequest) returns (Message) {
+ *         option (google.api.http) = {
+ *           get: "/v1/messages/{message_id}"
+ *           additional_bindings {
+ *             get: "/v1/users/{user_id}/messages/{message_id}"
+ *           }
+ *         };
  *       }
- *     };
- *   }
- * }
- * message GetMessageRequest {
- *   string message_id = 1;
- *   string user_id = 2;
- * }
- * ```
+ *     }
+ *     message GetMessageRequest {
+ *       string message_id = 1;
+ *       string user_id = 2;
+ *     }
+ *
  *
  * This enables the following two alternative HTTP JSON to RPC
  * mappings:
  *
  * HTTP | RPC
  * -----|-----
  * `GET /v1/messages/123456` | `GetMessage(message_id: "123456")`
  * `GET /v1/users/me/messages/123456` | `GetMessage(user_id: "me" message_id:
  * "123456")`
  *
@@ skipping 50 matching lines @@
   /**
    * Additional HTTP bindings for the selector. Nested bindings must
    * not contain an `additional_bindings` field themselves (that is,
    * the nesting may only be one level deep).
    */
   core.List<HttpRule> additionalBindings;
   /**
    * The name of the request field whose value is mapped to the HTTP body, or
    * `*` for mapping all fields not captured by the path pattern to the HTTP
    * body. NOTE: the referred field must not be a repeated field and must be
-   * present at the top-level of response message type.
+   * present at the top-level of request message type.
    */
   core.String body;
   /** Custom pattern is used for defining custom verbs. */
   CustomHttpPattern custom;
   /** Used for deleting a resource. */
   core.String delete;
   /** Used for listing and getting information about resources. */
   core.String get;
   /**
    * Do not use this. For media support, add instead
@@ skipping 1350 matching lines @@
     }
     return _json;
   }
 }
 
 /**
  * A protocol buffer option, which can be attached to a message, field,
  * enumeration, etc.
  */
 class Option {
-  /** The option's name. For example, `"java_package"`. */
+  /**
+   * The option's name. For protobuf built-in options (options defined in
+   * descriptor.proto), this is the short name. For example, `"map_entry"`.
+   * For custom options, it should be the fully-qualified name. For example,
+   * `"google.api.http"`.
+   */
   core.String name;
   /**
-   * The option's value. For example, `"com.google.protobuf"`.
+   * The option's value packed in an Any message. If the value is a primitive,
+   * the corresponding wrapper type defined in google/protobuf/wrappers.proto
+   * should be used. If the value is an enum, it should be stored as an int32
+   * value using the google.protobuf.Int32Value type.
    *
    * 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.Map<core.String, core.Object> value;
 
   Option();
 
   Option.fromJson(core.Map _json) {
     if (_json.containsKey("name")) {
@@ skipping 420 matching lines @@
  * specific aspect, such as auth. See each proto message definition for details.
  *
  * Example:
  *
  *     type: google.api.Service
  *     config_version: 3
  *     name: calendar.googleapis.com
  *     title: Google Calendar API
  *     apis:
  *     - name: google.calendar.v3.Calendar
- *     backend:
+ *     authentication:
+ *       providers:
+ *       - id: google_calendar_auth
+ *         jwks_uri: https://www.googleapis.com/oauth2/v1/certs
+ *         issuer: https://securetoken.google.com
  *       rules:
- *       - selector: "google.calendar.v3.*"
- *         address: calendar.example.com
+ *       - selector: "*"
+ *         requirements:
+ *           provider_id: google_calendar_auth
  */
 class Service {
   /**
    * A list of API interfaces exported by this service. Only the `name` field
    * of the google.protobuf.Api needs to be provided by the configuration
    * author, as the remaining fields will be derived from the IDL during the
    * normalization process. It is an error to specify an API interface here
    * which cannot be resolved against the associated IDL files.
    */
   core.List<Api> apis;
@@ skipping 511 matching lines @@
  * an HTTP header or a URL query parameter, and if both are passed the behavior
  * is implementation-dependent.
  */
 class SystemParameter {
   /**
    * Define the HTTP header name to use for the parameter. It is case
    * insensitive.
    */
   core.String httpHeader;
   /**
-   * Define the name of the parameter, such as "api_key", "alt", "callback",
-   * and etc. It is case sensitive.
+   * Define the name of the parameter, such as "api_key" . It is case sensitive.
    */
   core.String name;
   /**
    * Define the URL query parameter name to use for the parameter. It is case
    * sensitive.
    */
   core.String urlQueryParameter;
 
   SystemParameter();
 
@@ skipping 78 matching lines @@
  */
 class SystemParameters {
   /**
    * Define system parameters.
    *
    * The parameters defined here will override the default parameters
    * implemented by the system. If this field is missing from the service
    * config, default system parameters will be used. Default system parameters
    * and names is implementation-dependent.
    *
-   * Example: define api key and alt name for all methods
+   * Example: define api key for all methods
    *
-   * system_parameters
-   *   rules:
-   *     - selector: "*"
-   *       parameters:
-   *         - name: api_key
-   *           url_query_parameter: api_key
-   *         - name: alt
-   *           http_header: Response-Content-Type
+   *     system_parameters
+   *       rules:
+   *         - selector: "*"
+   *           parameters:
+   *             - name: api_key
+   *               url_query_parameter: api_key
+   *
    *
    * Example: define 2 api key names for a specific method.
    *
-   * system_parameters
-   *   rules:
-   *     - selector: "/ListShelves"
-   *       parameters:
-   *         - name: api_key
-   *           http_header: Api-Key1
-   *         - name: api_key
-   *           http_header: Api-Key2
+   *     system_parameters
+   *       rules:
+   *         - selector: "/ListShelves"
+   *           parameters:
+   *             - name: api_key
+   *               http_header: Api-Key1
+   *             - name: api_key
+   *               http_header: Api-Key2
    *
    * **NOTE:** All service configuration rules follow "last one wins" order.
    */
   core.List<SystemParameterRule> rules;
 
   SystemParameters();
 
   SystemParameters.fromJson(core.Map _json) {
     if (_json.containsKey("rules")) {
       rules = _json["rules"].map((value) => new SystemParameterRule.fromJson(value)).toList();
@@ skipping 202 matching lines @@
     if (service != null) {
       _json["service"] = (service).toJson();
     }
     return _json;
   }
 }
 
 /** Configuration controlling usage of a service. */
 class Usage {
   /**
+   * The full resource name of a channel used for sending notifications to the
+   * service producer.
+   *
+   * Google Service Management currently only supports
+   * [Google Cloud Pub/Sub](https://cloud.google.com/pubsub) as a notification
+   * channel. To use Google Cloud Pub/Sub as the channel, this must be the name
+   * of a Cloud Pub/Sub topic that uses the Cloud Pub/Sub topic name format
+   * documented in https://cloud.google.com/pubsub/docs/overview.
+   */
+  core.String producerNotificationChannel;
+  /**
    * Requirements that must be satisfied before a consumer project can use the
    * service. Each requirement is of the form <service.name>/<requirement-id>;
    * for example 'serviceusage.googleapis.com/billing-enabled'.
    */
   core.List<core.String> requirements;
   /**
    * A list of usage rules that apply to individual API methods.
    *
    * **NOTE:** All service configuration rules follow "last one wins" order.
    */
   core.List<UsageRule> rules;
 
   Usage();
 
   Usage.fromJson(core.Map _json) {
+    if (_json.containsKey("producerNotificationChannel")) {
+      producerNotificationChannel = _json["producerNotificationChannel"];
+    }
     if (_json.containsKey("requirements")) {
       requirements = _json["requirements"];
     }
     if (_json.containsKey("rules")) {
       rules = _json["rules"].map((value) => new UsageRule.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
+    if (producerNotificationChannel != null) {
+      _json["producerNotificationChannel"] = producerNotificationChannel;
+    }
     if (requirements != null) {
       _json["requirements"] = requirements;
     }
     if (rules != null) {
       _json["rules"] = rules.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
@@ skipping 152 matching lines @@
     var _json = new core.Map();
     if (restriction != null) {
       _json["restriction"] = restriction;
     }
     if (selector != null) {
       _json["selector"] = selector;
     }
     return _json;
   }
 }