# Google Service User API . projects . services

## Instance Methods

Disable a service so it can no longer be used with a

Enable a service so it can be used with a project.

List enabled services for the specified consumer.

Retrieves the next page of results.

### Method Details

`disable(name, body, x__xgafv=None)`

    Disable a service so it can no longer be used with a
    project. This prevents unintended usage that may cause unexpected billing
    charges or security leaks.

    Operation

    Args:
      name: string, Name of the consumer and the service to disable for that consumer.

    The Service User implementation accepts the following forms for consumer:
    - "project:"

    A valid path would be:
    - /v1/projects/my-project/services/servicemanagement.googleapis.com:disable (required)
      body: object, The request body. (required)
        The object takes the form of:

    { # Request message for DisableService method.
      }

      x__xgafv: string, V1 error format.
        Allowed values
          1 - v1 error format
          2 - v2 error format

    Returns:
      An object of the form:

        { # This resource represents a long-running operation that is the result of a
          # network API call.
        "error": { # The `Status` type defines a logical error model that is suitable for different # The error result of the operation in case of failure or cancellation.
            # programming environments, including REST APIs and RPC APIs. It is used by
            # [gRPC](https://github.com/grpc). The error model is designed to be:
            #
            # - Simple to use and understand for most users
            # - Flexible enough to meet unexpected needs
            #
            # # Overview
            #
            # The `Status` message contains three pieces of data: error code, error message,
            # and error details. The error code should be an enum value of
            # google.rpc.Code, but it may accept additional error codes if needed.  The
            # error message should be a developer-facing English message that helps
            # developers *understand* and *resolve* the error. If a localized user-facing
            # error message is needed, put the localized message in the error details or
            # localize it in the client. The optional error details may contain arbitrary
            # information about the error. There is a predefined set of error detail types
            # in the package `google.rpc` that can be used for common error conditions.
            #
            # # Language mapping
            #
            # The `Status` message is the logical representation of the error model, but it
            # is not necessarily the actual wire format. When the `Status` message is
            # exposed in different client libraries and different wire protocols, it can be
            # mapped differently. For example, it will likely be mapped to some exceptions
            # in Java, but more likely mapped to some error codes in C.
            #
            # # Other uses
            #
            # The error model and the `Status` message can be used in a variety of
            # environments, either with or without APIs, to provide a
            # consistent developer experience across different environments.
            #
            # Example uses of this error model include:
            #
            # - Partial errors. If a service needs to return partial errors to the client,
            #     it may embed the `Status` in the normal response to indicate the partial
            #     errors.
            #
            # - Workflow errors. A typical workflow has multiple steps. Each step may
            #     have a `Status` message for error reporting.
            #
            # - Batch operations. If a client uses batch request and batch response, the
            #     `Status` message should be used directly inside batch response, one for
            #     each error sub-response.
            #
            # - Asynchronous operations. If an API call embeds asynchronous operation
            #     results in its response, the status of those operations should be
            #     represented directly using the `Status` message.
            #
            # - Logging. If some API errors are stored in logs, the message `Status` could
            #     be used directly after any stripping needed for security/privacy reasons.
          "message": "A String", # A developer-facing error message, which should be in English. Any
              # user-facing error message should be localized and sent in the
              # google.rpc.Status.details field, or localized by the client.
          "code": 42, # The status code, which should be an enum value of google.rpc.Code.
          "details": [ # A list of messages that carry the error details.  There will be a
              # common set of message types for APIs to use.
            {
              "a_key": "", # Properties of the object. Contains field @type with type URL.
            },
          ],
        },
        "done": True or False, # If the value is `false`, it means the operation is still in progress.
            # If true, the operation is completed, and either `error` or `response` is
            # available.
        "response": { # The normal response of the operation in case of success.  If the original
            # method returns no data on success, such as `Delete`, the response is
            # `google.protobuf.Empty`.  If the original method is standard
            # `Get`/`Create`/`Update`, the response should be the resource.  For other
            # methods, the response should have the type `XxxResponse`, where `Xxx`
            # is the original method name.  For example, if the original method name
            # is `TakeSnapshot()`, the inferred response type is
            # `TakeSnapshotResponse`.
          "a_key": "", # Properties of the object. Contains field @type with type URL.
        },
        "name": "A String", # The server-assigned name, which is only unique within the same service that
            # originally returns it. If you use the default HTTP mapping, the
            # `name` should have the format of `operations/some/unique/name`.
        "metadata": { # Service-specific metadata associated with the operation.  It typically
            # contains progress information and common metadata such as create time.
            # Some services might not provide such metadata.  Any method that returns a
            # long-running operation should document the metadata type, if any.
          "a_key": "", # Properties of the object. Contains field @type with type URL.
        },
      }

`enable(name, body, x__xgafv=None)`

    Enable a service so it can be used with a project.
    See [Cloud Auth Guide](https://cloud.google.com/docs/authentication) for
    more information.

    Operation

    Args:
      name: string, Name of the consumer and the service to enable for that consumer.

    A valid path would be:
    - /v1/projects/my-project/services/servicemanagement.googleapis.com:enable (required)
      body: object, The request body. (required)
        The object takes the form of:

    { # Request message for EnableService method.
      }

      x__xgafv: string, V1 error format.
        Allowed values
          1 - v1 error format
          2 - v2 error format

    Returns:
      An object of the form:

        { # This resource represents a long-running operation that is the result of a
          # network API call.
        "error": { # The `Status` type defines a logical error model that is suitable for different # The error result of the operation in case of failure or cancellation.
            # programming environments, including REST APIs and RPC APIs. It is used by
            # [gRPC](https://github.com/grpc). The error model is designed to be:
            #
            # - Simple to use and understand for most users
            # - Flexible enough to meet unexpected needs
            #
            # # Overview
            #
            # The `Status` message contains three pieces of data: error code, error message,
            # and error details. The error code should be an enum value of
            # google.rpc.Code, but it may accept additional error codes if needed.  The
            # error message should be a developer-facing English message that helps
            # developers *understand* and *resolve* the error. If a localized user-facing
            # error message is needed, put the localized message in the error details or
            # localize it in the client. The optional error details may contain arbitrary
            # information about the error. There is a predefined set of error detail types
            # in the package `google.rpc` that can be used for common error conditions.
            #
            # # Language mapping
            #
            # The `Status` message is the logical representation of the error model, but it
            # is not necessarily the actual wire format. When the `Status` message is
            # exposed in different client libraries and different wire protocols, it can be
            # mapped differently. For example, it will likely be mapped to some exceptions
            # in Java, but more likely mapped to some error codes in C.
            #
            # # Other uses
            #
            # The error model and the `Status` message can be used in a variety of
            # environments, either with or without APIs, to provide a
            # consistent developer experience across different environments.
            #
            # Example uses of this error model include:
            #
            # - Partial errors. If a service needs to return partial errors to the client,
            #     it may embed the `Status` in the normal response to indicate the partial
            #     errors.
            #
            # - Workflow errors. A typical workflow has multiple steps. Each step may
            #     have a `Status` message for error reporting.
            #
            # - Batch operations. If a client uses batch request and batch response, the
            #     `Status` message should be used directly inside batch response, one for
            #     each error sub-response.
            #
            # - Asynchronous operations. If an API call embeds asynchronous operation
            #     results in its response, the status of those operations should be
            #     represented directly using the `Status` message.
            #
            # - Logging. If some API errors are stored in logs, the message `Status` could
            #     be used directly after any stripping needed for security/privacy reasons.
          "message": "A String", # A developer-facing error message, which should be in English. Any
              # user-facing error message should be localized and sent in the
              # google.rpc.Status.details field, or localized by the client.
          "code": 42, # The status code, which should be an enum value of google.rpc.Code.
          "details": [ # A list of messages that carry the error details.  There will be a
              # common set of message types for APIs to use.
            {
              "a_key": "", # Properties of the object. Contains field @type with type URL.
            },
          ],
        },
        "done": True or False, # If the value is `false`, it means the operation is still in progress.
            # If true, the operation is completed, and either `error` or `response` is
            # available.
        "response": { # The normal response of the operation in case of success.  If the original
            # method returns no data on success, such as `Delete`, the response is
            # `google.protobuf.Empty`.  If the original method is standard
            # `Get`/`Create`/`Update`, the response should be the resource.  For other
            # methods, the response should have the type `XxxResponse`, where `Xxx`
            # is the original method name.  For example, if the original method name
            # is `TakeSnapshot()`, the inferred response type is
            # `TakeSnapshotResponse`.
          "a_key": "", # Properties of the object. Contains field @type with type URL.
        },
        "name": "A String", # The server-assigned name, which is only unique within the same service that
            # originally returns it. If you use the default HTTP mapping, the
            # `name` should have the format of `operations/some/unique/name`.
        "metadata": { # Service-specific metadata associated with the operation.  It typically
            # contains progress information and common metadata such as create time.
            # Some services might not provide such metadata.  Any method that returns a
            # long-running operation should document the metadata type, if any.
          "a_key": "", # Properties of the object. Contains field @type with type URL.
        },
      }

`list(parent, pageToken=None, x__xgafv=None, pageSize=None)`

    List enabled services for the specified consumer.

    Args:
      parent: string, List enabled services for the specified parent.

    An example valid parent would be:
    - projects/my-project (required)
      pageToken: string, Token identifying which result to start with; returned by a previous list
    call.
      x__xgafv: string, V1 error format.
        Allowed values
          1 - v1 error format
          2 - v2 error format
      pageSize: integer, Requested size of the next page of data.

    Returns:
      An object of the form:

        { # Response message for `ListEnabledServices` method.
        "services": [ # Services enabled for the specified parent.
          { # The published version of a Service that is managed by
              # Google Service Management.
            "name": "A String", # The resource name of the service.
                #
                # A valid name would be:
                # - services/serviceuser.googleapis.com
            "service": { # `Service` is the root object of Google service configuration schema. It # The service's published configuration.
                # describes basic information about a service, such as the name and the
                # title, and delegates other aspects to sub-sections. Each sub-section is
                # either a proto message or a repeated proto message that configures a
                # 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
                #     authentication:
                #       providers:
                #       - id: google_calendar_auth
                #         jwks_uri: https://www.googleapis.com/oauth2/v1/certs
                #         issuer: https://securetoken.google.com
                #       rules:
                #       - selector: "*"
                #         requirements:
                #           provider_id: google_calendar_auth
              "control": { # Selects and configures the service controller used by the service.  The # Configuration for the service control plane.
                  # service controller handles features like abuse, quota, billing, logging,
                  # monitoring, etc.
                "environment": "A String", # The service control environment to use. If empty, no control plane
                    # feature (like quota and billing) will be enabled.
              },
              "monitoredResources": [ # Defines the monitored resources used by this service. This is required
                  # by the Service.monitoring and Service.logging configurations.
                { # An object that describes the schema of a MonitoredResource object using a
                    # type name and a set of labels.  For example, the monitored resource
                    # descriptor for Google Compute Engine VM instances has a type of
                    # `"gce_instance"` and specifies the use of the labels `"instance_id"` and
                    # `"zone"` to identify particular VM instances.
                    #
                    # Different APIs can support different monitored resource types. APIs generally
                    # provide a `list` method that returns the monitored resource descriptors used
                    # by the API.
                  "type": "A String", # Required. The monitored resource type. For example, the type
                      # `"cloudsql_database"` represents databases in Google Cloud SQL.
                      # The maximum length of this value is 256 characters.
                  "labels": [ # Required. A set of labels used to describe instances of this monitored
                      # resource type. For example, an individual Google Cloud SQL database is
                      # identified by values for the labels `"database_id"` and `"zone"`.
                    { # A description of a label.
                      "valueType": "A String", # The type of data that can be assigned to the label.
                      "description": "A String", # A human-readable description for the label.
                      "key": "A String", # The label key.
                    },
                  ],
                  "displayName": "A String", # Optional. A concise name for the monitored resource type that might be
                      # displayed in user interfaces. It should be a Title Cased Noun Phrase,
                      # without any article or other determiners. For example,
                      # `"Google Cloud SQL Database"`.
                  "name": "A String", # Optional. The resource name of the monitored resource descriptor:
                      # `"projects/{project_id}/monitoredResourceDescriptors/{type}"` where
                      # {type} is the value of the `type` field in this object and
                      # {project_id} is a project ID that provides API-specific context for
                      # accessing the type.  APIs that do not use project information can use the
                      # resource name format `"monitoredResourceDescriptors/{type}"`.
                  "description": "A String", # Optional. A detailed description of the monitored resource type that might
                      # be used in documentation.
                },
              ],
              "logs": [ # Defines the logs used by this service.
                { # A description of a log type. Example in YAML format:
                    #
                    #     - name: library.googleapis.com/activity_history
                    #       description: The history of borrowing and returning library items.
                    #       display_name: Activity
                    #       labels:
                    #       - key: /customer_id
                    #         description: Identifier of a library customer
                  "labels": [ # The set of labels that are available to describe a specific log entry.
                      # Runtime requests that contain labels not specified here are
                      # considered invalid.
                    { # A description of a label.
                      "valueType": "A String", # The type of data that can be assigned to the label.
                      "description": "A String", # A human-readable description for the label.
                      "key": "A String", # The label key.
                    },
                  ],
                  "displayName": "A String", # The human-readable name for this log. This information appears on
                      # the user interface and should be concise.
                  "name": "A String", # The name of the log. It must be less than 512 characters long and can
                      # include the following characters: upper- and lower-case alphanumeric
                      # characters [A-Za-z0-9], and punctuation characters including
                      # slash, underscore, hyphen, period [/_-.].
                  "description": "A String", # A human-readable description of this log. This information appears in
                      # the documentation and can contain details.
                },
              ],
              "systemParameters": { # ### System parameter configuration # System parameter configuration.
                  #
                  # A system parameter is a special kind of parameter defined by the API
                  # system, not by an individual API. It is typically mapped to an HTTP header
                  # and/or a URL query parameter. This configuration specifies which methods
                  # change the names of the system parameters.
                "rules": [ # 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 for all methods
                    #
                    #     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
                    #
                    # **NOTE:** All service configuration rules follow "last one wins" order.
                  { # Define a system parameter rule mapping system parameter definitions to
                      # methods.
                    "parameters": [ # Define parameters. Multiple names may be defined for a parameter.
                        # For a given method call, only one of them should be used. If multiple
                        # names are used the behavior is implementation-dependent.
                        # If none of the specified names are present the behavior is
                        # parameter-dependent.
                      { # Define a parameter's name and location. The parameter may be passed as either
                          # an HTTP header or a URL query parameter, and if both are passed the behavior
                          # is implementation-dependent.
                        "urlQueryParameter": "A String", # Define the URL query parameter name to use for the parameter. It is case
                            # sensitive.
                        "httpHeader": "A String", # Define the HTTP header name to use for the parameter. It is case
                            # insensitive.
                        "name": "A String", # Define the name of the parameter, such as "api_key" . It is case sensitive.
                      },
                    ],
                    "selector": "A String", # Selects the methods to which this rule applies. Use '*' to indicate all
                        # methods in all APIs.
                        #
                        # Refer to selector for syntax details.
                  },
                ],
              },
              "id": "A String", # A unique ID for a specific instance of this message, typically assigned
                  # by the client for tracking purpose. If empty, the server may choose to
                  # generate one instead.
              "backend": { # `Backend` defines the backend configuration for a service. # API backend configuration.
                "rules": [ # A list of API backend rules that apply to individual API methods.
                    #
                    # **NOTE:** All service configuration rules follow "last one wins" order.
                  { # A backend rule provides configuration for an individual API element.
                    "selector": "A String", # Selects the methods to which this rule applies.
                        #
                        # Refer to selector for syntax details.
                    "minDeadline": 3.14, # Minimum deadline in seconds needed for this method. Calls having deadline
                        # value lower than this will be rejected.
                    "deadline": 3.14, # The number of seconds to wait for a response from a request.  The
                        # default depends on the deployment context.
                    "address": "A String", # The address of the API backend.
                  },
                ],
              },
              "monitoring": { # Monitoring configuration of the service. # Monitoring configuration.
                  #
                  # The example below shows how to configure monitored resources and metrics
                  # for monitoring. In the example, a monitored resource and two metrics are
                  # defined. The `library.googleapis.com/book/returned_count` metric is sent
                  # to both producer and consumer projects, whereas the
                  # `library.googleapis.com/book/overdue_count` metric is only sent to the
                  # consumer project.
                  #
                  #     monitored_resources:
                  #     - type: library.googleapis.com/branch
                  #       labels:
                  #       - key: /city
                  #         description: The city where the library branch is located in.
                  #       - key: /name
                  #         description: The name of the branch.
                  #     metrics:
                  #     - name: library.googleapis.com/book/returned_count
                  #       metric_kind: DELTA
                  #       value_type: INT64
                  #       labels:
                  #       - key: /customer_id
                  #     - name: library.googleapis.com/book/overdue_count
                  #       metric_kind: GAUGE
                  #       value_type: INT64
                  #       labels:
                  #       - key: /customer_id
                  #     monitoring:
                  #       producer_destinations:
                  #       - monitored_resource: library.googleapis.com/branch
                  #         metrics:
                  #         - library.googleapis.com/book/returned_count
                  #       consumer_destinations:
                  #       - monitored_resource: library.googleapis.com/branch
                  #         metrics:
                  #         - library.googleapis.com/book/returned_count
                  #         - library.googleapis.com/book/overdue_count
                "producerDestinations": [ # Monitoring configurations for sending metrics to the producer project.
                    # There can be multiple producer destinations, each one must have a
                    # different monitored resource type. A metric can be used in at most
                    # one producer destination.
                  { # Configuration of a specific monitoring destination (the producer project
                      # or the consumer project).
                    "monitoredResource": "A String", # The monitored resource type. The type must be defined in
                        # Service.monitored_resources section.
                    "metrics": [ # Names of the metrics to report to this monitoring destination.
                        # Each name must be defined in Service.metrics section.
                      "A String",
                    ],
                  },
                ],
                "consumerDestinations": [ # Monitoring configurations for sending metrics to the consumer project.
                    # There can be multiple consumer destinations, each one must have a
                    # different monitored resource type. A metric can be used in at most
                    # one consumer destination.
                  { # Configuration of a specific monitoring destination (the producer project
                      # or the consumer project).
                    "monitoredResource": "A String", # The monitored resource type. The type must be defined in
                        # Service.monitored_resources section.
                    "metrics": [ # Names of the metrics to report to this monitoring destination.
                        # Each name must be defined in Service.metrics section.
                      "A String",
                    ],
                  },
                ],
              },
              "title": "A String", # The product title associated with this service.
              "authentication": { # `Authentication` defines the authentication configuration for an API. # Auth configuration.
                  #
                  # 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: "*"
                  #         requirements:
                  #           provider_id: google_calendar_auth
                "rules": [ # A list of authentication rules that apply to individual API methods.
                    #
                    # **NOTE:** All service configuration rules follow "last one wins" order.
                  { # Authentication rules for the service.
                      #
                      # By default, if a method has any authentication requirements, every request
                      # must include a valid credential matching one of the requirements.
                      # It's an error to include more than one kind of credential in a single
                      # request.
                      #
                      # If a method doesn't have any auth requirements, request credentials will be
                      # ignored.
                    "oauth": { # OAuth scopes are a way to define data and permissions on data. For example, # The requirements for OAuth credentials.
                        # there are scopes defined for "Read-only access to Google Calendar" and
                        # "Access to Cloud Platform". Users can consent to a scope for an application,
                        # giving it permission to access that data on their behalf.
                        #
                        # OAuth scope specifications should be fairly coarse grained; a user will need
                        # to see and understand the text description of what your scope means.
                        #
                        # In most cases: use one or at most two OAuth scopes for an entire family of
                        # products. If your product has multiple APIs, you should probably be sharing
                        # the OAuth scope across all of those APIs.
                        #
                        # When you need finer grained OAuth consent screens: talk with your product
                        # management about how developers will use them in practice.
                        #
                        # Please note that even though each of the canonical scopes is enough for a
                        # request to be accepted and passed to the backend, a request can still fail
                        # due to the backend requiring additional scopes or permissions.
                      "canonicalScopes": "A String", # The list of publicly documented OAuth scopes that are allowed access. An
                          # OAuth token containing any of these scopes will be accepted.
                          #
                          # Example:
                          #
                          #      canonical_scopes: https://www.googleapis.com/auth/calendar,
                          #                        https://www.googleapis.com/auth/calendar.read
                    },
                    "allowWithoutCredential": True or False, # Whether to allow requests without a credential. The credential can be
                        # an OAuth token, Google cookies (first-party auth) or EndUserCreds.
                        #
                        # For requests without credentials, if the service control environment is
                        # specified, each incoming request **must** be associated with a service
                        # consumer. This can be done by passing an API key that belongs to a consumer
                        # project.
                    "requirements": [ # Requirements for additional authentication providers.
                      { # User-defined authentication requirements, including support for
                          # [JSON Web Token (JWT)](https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32).
                        "providerId": "A String", # id from authentication provider.
                            #
                            # Example:
                            #
                            #     provider_id: bookstore_auth
                        "audiences": "A String", # NOTE: This will be deprecated soon, once AuthProvider.audiences is
                            # implemented and accepted in all the runtime components.
                            #
                            # 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
                            # be accepted. When this setting is absent, only JWTs with audience
                            # "https://Service_name/API_name"
                            # will be accepted. For example, if no audiences are in the setting,
                            # LibraryService API will only accept JWTs with the following audience
                            # "https://library-example.googleapis.com/google.example.library.v1.LibraryService".
                            #
                            # Example:
                            #
                            #     audiences: bookstore_android.apps.googleusercontent.com,
                            #                bookstore_web.apps.googleusercontent.com
                      },
                    ],
                    "customAuth": { # Configuration for a custom authentication provider. # Configuration for custom authentication.
                      "provider": "A String", # A configuration string containing connection information for the
                          # authentication provider, typically formatted as a SmartService string
                          # (go/smartservice).
                    },
                    "selector": "A String", # Selects the methods to which this rule applies.
                        #
                        # Refer to selector for syntax details.
                  },
                ],
                "providers": [ # Defines a set of authentication providers that a service supports.
                  { # Configuration for an anthentication provider, including support for
                      # [JSON Web Token (JWT)](https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32).
                    "audiences": "A String", # 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
                        # be accepted. When this setting is absent, only JWTs with audience
                        # "https://Service_name/API_name"
                        # will be accepted. For example, if no audiences are in the setting,
                        # LibraryService API will only accept JWTs with the following audience
                        # "https://library-example.googleapis.com/google.example.library.v1.LibraryService".
                        #
                        # Example:
                        #
                        #     audiences: bookstore_android.apps.googleusercontent.com,
                        #                bookstore_web.apps.googleusercontent.com
                    "jwksUri": "A String", # URL of the provider's public key set to validate signature of the JWT. See
                        # [OpenID Discovery](https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderMetadata).
                        # Optional if the key set document:
                        #  - can be retrieved from
                        #    [OpenID Discovery](https://openid.net/specs/openid-connect-discovery-1_0.html
                        #    of the issuer.
                        #  - can be inferred from the email domain of the issuer (e.g. a Google service account).
                        #
                        # Example: https://www.googleapis.com/oauth2/v1/certs
                    "id": "A String", # The unique identifier of the auth provider. It will be referred to by
                        # `AuthRequirement.provider_id`.
                        #
                        # Example: "bookstore_auth".
                    "issuer": "A String", # Identifies the principal that issued the JWT. See
                        # https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32#section-4.1.1
                        # Usually a URL or an email address.
                        #
                        # Example: https://securetoken.google.com
                        # Example: 1234567-compute@developer.gserviceaccount.com
                  },
                ],
              },
              "usage": { # Configuration controlling usage of a service. # Configuration controlling usage of this service.
                "rules": [ # A list of usage rules that apply to individual API methods.
                    #
                    # **NOTE:** All service configuration rules follow "last one wins" order.
                  { # Usage configuration rules for the service.
                      #
                      # NOTE: Under development.
                      #
                      #
                      # Use this rule to configure unregistered calls for the service. Unregistered
                      # calls are calls that do not contain consumer project identity.
                      # (Example: calls that do not contain an API key).
                      # By default, API methods do not allow unregistered calls, and each method call
                      # must be identified by a consumer project identity. Use this rule to
                      # allow/disallow unregistered calls.
                      #
                      # Example of an API that wants to allow unregistered calls for entire service.
                      #
                      #     usage:
                      #       rules:
                      #       - selector: "*"
                      #         allow_unregistered_calls: true
                      #
                      # Example of a method that wants to allow unregistered calls.
                      #
                      #     usage:
                      #       rules:
                      #       - selector: "google.example.library.v1.LibraryService.CreateBook"
                      #         allow_unregistered_calls: true
                    "selector": "A String", # Selects the methods to which this rule applies. Use '*' to indicate all
                        # methods in all APIs.
                        #
                        # Refer to selector for syntax details.
                    "allowUnregisteredCalls": True or False, # True, if the method allows unregistered calls; false otherwise.
                  },
                ],
                "producerNotificationChannel": "A String", # 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.
                "requirements": [ # Requirements that must be satisfied before a consumer project can use the
                    # service. Each requirement is of the form /;
                    # for example 'serviceusage.googleapis.com/billing-enabled'.
                  "A String",
                ],
              },
              "configVersion": 42, # The version of the service configuration. The config version may
                  # influence interpretation of the configuration, for example, to
                  # determine defaults. This is documented together with applicable
                  # options. The current default for the config version itself is `3`.
              "producerProjectId": "A String", # 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.
              "http": { # Defines the HTTP configuration for a service. It contains a list of # HTTP configuration.
                  # HttpRule, each specifying the mapping of an RPC method
                  # to one or more HTTP REST API methods.
                "rules": [ # A list of HTTP configuration rules that apply to individual API methods.
                    #
                    # **NOTE:** All service configuration rules follow "last one wins" order.
                  { # `HttpRule` defines the mapping of an RPC method to one or more HTTP
                      # REST APIs.  The mapping determines what portions of the request
                      # 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:
                      #
                      #
                      #     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
                      #     }
                      #
                      # The same http annotation can alternatively be expressed inside the
                      # `GRPC API Configuration` YAML file.
                      #
                      #     http:
                      #       rules:
                      #         - selector: .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:
                      #
                      #
                      #     service Messaging {
                      #       rpc GetMessage(GetMessageRequest) returns (Message) {
                      #         option (google.api.http).get = "/v1/messages/{message_id}";
                      #       }
                      #     }
                      #     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¶m=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:
                      #
                      #
                      #     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:
                      #
                      #     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:
                      #
                      #     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;
                      #     }
                      #
                      #
                      # 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")`
                      #
                      # # Rules for HTTP mapping
                      #
                      # The rules for mapping HTTP path, query parameters, and body fields
                      # to the request message are as follows:
                      #
                      # 1. The `body` field specifies either `*` or a field path, or is
                      #    omitted. If omitted, it assumes there is no HTTP body.
                      # 2. Leaf fields (recursive expansion of nested messages in the
                      #    request) can be classified into three types:
                      #     (a) Matched in the URL template.
                      #     (b) Covered by body (if body is `*`, everything except (a) fields;
                      #         else everything under the body field)
                      #     (c) All other fields.
                      # 3. URL query parameters found in the HTTP request are mapped to (c) fields.
                      # 4. Any body sent with an HTTP request can contain only (b) fields.
                      #
                      # The syntax of the path template is as follows:
                      #
                      #     Template = "/" Segments [ Verb ] ;
                      #     Segments = Segment { "/" Segment } ;
                      #     Segment  = "*" | "**" | LITERAL | Variable ;
                      #     Variable = "{" FieldPath [ "=" Segments ] "}" ;
                      #     FieldPath = IDENT { "." IDENT } ;
                      #     Verb     = ":" LITERAL ;
                      #
                      # The syntax `*` matches a single path segment. It follows the semantics of
                      # [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2 Simple String
                      # Expansion.
                      #
                      # The syntax `**` matches zero or more path segments. It follows the semantics
                      # of [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.3 Reserved
                      # Expansion. NOTE: it must be the last segment in the path except the Verb.
                      #
                      # The syntax `LITERAL` matches literal text in the URL path.
                      #
                      # The syntax `Variable` matches the entire path as specified by its template;
                      # this nested template must not contain further variables. If a variable
                      # matches a single path segment, its template may be omitted, e.g. `{var}`
                      # is equivalent to `{var=*}`.
                      #
                      # NOTE: the field paths in variables and in the `body` must not refer to
                      # repeated fields or map fields.
                      #
                      # Use CustomHttpPattern to specify any HTTP method that is not included in the
                      # `pattern` field, such as HEAD, or "*" to leave the HTTP method unspecified for
                      # a given URL path rule. The wild-card rule is useful for services that provide
                      # content to Web (HTML) clients.
                    "body": "A String", # 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 request message type.
                    "get": "A String", # Used for listing and getting information about resources.
                    "restCollection": "A String", # Optional. The REST collection name is by default derived from the URL
                        # pattern. If specified, this field overrides the default collection name.
                        # Example:
                        #
                        #     rpc AddressesAggregatedList(AddressesAggregatedListRequest)
                        #         returns (AddressesAggregatedListResponse) {
                        #       option (google.api.http) = {
                        #         get: "/v1/projects/{project_id}/aggregated/addresses"
                        #         rest_collection: "projects.addresses"
                        #       };
                        #     }
                        #
                        # This method has the automatically derived collection name
                        # "projects.aggregated". Because, semantically, this rpc is actually an
                        # operation on the "projects.addresses" collection, the `rest_collection`
                        # field is configured to override the derived collection name.
                    "additionalBindings": [ # 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).
                      # Object with schema name: HttpRule
                    ],
                    "mediaUpload": { # Defines the Media configuration for a service in case of an upload. # Use this only for Scotty Requests. Do not use this for media support using
                        # Bytestream, add instead
                        # [][google.bytestream.RestByteStream] as an API to your
                        # configuration for Bytestream methods.
                        # Use this only for Scotty Requests. Do not use this for media support using
                        # Bytestream, add instead [][google.bytestream.RestByteStream] as an API to
                        # your configuration for Bytestream methods.
                      "startNotification": True or False, # Whether to receive a notification on the start of media upload.
                      "progressNotification": True or False, # Whether to receive a notification for progress changes of media upload.
                      "mimeTypes": [ # An array of mimetype patterns. Esf will only accept uploads that match one
                          # of the given patterns.
                        "A String",
                      ],
                      "enabled": True or False, # Whether upload is enabled.
                      "completeNotification": True or False, # A boolean that determines whether a notification for the completion of an
                          # upload should be sent to the backend. These notifications will not be seen
                          # by the client and will not consume quota.
                      "dropzone": "A String", # Name of the Scotty dropzone to use for the current API.
                      "maxSize": "A String", # Optional maximum acceptable size for an upload.
                          # The size is specified in bytes.
                      "uploadService": "A String", # DO NOT USE FIELDS BELOW THIS LINE UNTIL THIS WARNING IS REMOVED.
                          #
                          # Specify name of the upload service if one is used for upload.
                    },
                    "selector": "A String", # Selects methods to which this rule applies.
                        #
                        # Refer to selector for syntax details.
                    "responseBody": "A String", # The name of the response field whose value is mapped to the HTTP body of
                        # response. Other response fields are ignored. This field is optional. When
                        # not set, the response message will be used as HTTP body of response.
                        # NOTE: the referred field must be not a repeated field and must be present
                        # at the top-level of response message type.
                    "restMethodName": "A String", # Optional. The rest method name is by default derived from the URL
                        # pattern. If specified, this field overrides the default method name.
                        # Example:
                        #
                        #     rpc CreateResource(CreateResourceRequest)
                        #         returns (CreateResourceResponse) {
                        #       option (google.api.http) = {
                        #         post: "/v1/resources",
                        #         body: "resource",
                        #         rest_method_name: "insert"
                        #       };
                        #     }
                        #
                        # This method has the automatically derived rest method name "create", but
                        #  for backwards compatability with apiary, it is specified as insert.
                    "mediaDownload": { # Defines the Media configuration for a service in case of a download. # Use this only for Scotty Requests. Do not use this for bytestream methods.
                        # For media support, add instead [][google.bytestream.RestByteStream] as an
                        # API to your configuration.
                        # Use this only for Scotty Requests. Do not use this for media support using
                        # Bytestream, add instead [][google.bytestream.RestByteStream] as an API to
                        # your configuration for Bytestream methods.
                      "useDirectDownload": True or False, # A boolean that determines if direct download from ESF should be used for
                          # download of this media.
                      "completeNotification": True or False, # A boolean that determines whether a notification for the completion of a
                          # download should be sent to the backend.
                      "enabled": True or False, # Whether download is enabled.
                      "maxDirectDownloadSize": "A String", # Optional maximum acceptable size for direct download.
                          # The size is specified in bytes.
                      "dropzone": "A String", # Name of the Scotty dropzone to use for the current API.
                      "downloadService": "A String", # DO NOT USE FIELDS BELOW THIS LINE UNTIL THIS WARNING IS REMOVED.
                          #
                          # Specify name of the download service if one is used for download.
                    },
                    "put": "A String", # Used for updating a resource.
                    "patch": "A String", # Used for updating a resource.
                    "post": "A String", # Used for creating a resource.
                    "custom": { # A custom pattern is used for defining custom HTTP verb. # Custom pattern is used for defining custom verbs.
                      "path": "A String", # The path matched by this custom verb.
                      "kind": "A String", # The name of this custom HTTP verb.
                    },
                    "delete": "A String", # Used for deleting a resource.
                  },
                ],
                "fullyDecodeReservedExpansion": True or False, # 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.
              },
              "apis": [ # 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.
                { # Api is a light-weight descriptor for a protocol buffer service.
                  "name": "A String", # The fully qualified name of this api, including package name
                      # followed by the api's simple name.
                  "sourceContext": { # `SourceContext` represents information about the source of a # Source context for the protocol buffer service represented by this
                      # message.
                      # protobuf element, like the file in which it is defined.
                    "fileName": "A String", # The path-qualified name of the .proto file that contained the associated
                        # protobuf element.  For example: `"google/protobuf/source_context.proto"`.
                  },
                  "mixins": [ # Included APIs. See Mixin.
                    { # 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
                        #   inherited.
                        #
                        # - If an http annotation is inherited, the path pattern will be
                        #   modified as follows. Any version prefix will be replaced by the
                        #   version of the including API plus the root path if specified.
                        #
                        # Example of a simple mixin:
                        #
                        #     package google.acl.v1;
                        #     service AccessControl {
                        #       // Get the underlying ACL object.
                        #       rpc GetAcl(GetAclRequest) returns (Acl) {
                        #         option (google.api.http).get = "/v1/{resource=**}:getAcl";
                        #       }
                        #     }
                        #
                        #     package google.storage.v2;
                        #     service Storage {
                        #       //       rpc GetAcl(GetAclRequest) returns (Acl);
                        #
                        #       // Get a data record.
                        #       rpc GetData(GetDataRequest) returns (Data) {
                        #         option (google.api.http).get = "/v2/{resource=**}";
                        #       }
                        #     }
                        #
                        # Example of a mixin configuration:
                        #
                        #     apis:
                        #     - name: google.storage.v2.Storage
                        #       mixins:
                        #       - name: google.acl.v1.AccessControl
                        #
                        # The mixin construct implies that all methods in `AccessControl` are
                        # also declared with same name and request/response types in
                        # `Storage`. A documentation generator or annotation processor will
                        # see the effective `Storage.GetAcl` method after inherting
                        # documentation and annotations as follows:
                        #
                        #     service Storage {
                        #       // Get the underlying ACL object.
                        #       rpc GetAcl(GetAclRequest) returns (Acl) {
                        #         option (google.api.http).get = "/v2/{resource=**}:getAcl";
                        #       }
                        #       ...
                        #     }
                        #
                        # Note how the version in the path pattern changed from `v1` to `v2`.
                        #
                        # If the `root` field in the mixin is specified, it should be a
                        # relative path under which inherited HTTP paths are placed. Example:
                        #
                        #     apis:
                        #     - name: google.storage.v2.Storage
                        #       mixins:
                        #       - name: google.acl.v1.AccessControl
                        #         root: acls
                        #
                        # This implies the following inherited HTTP annotation:
                        #
                        #     service Storage {
                        #       // Get the underlying ACL object.
                        #       rpc GetAcl(GetAclRequest) returns (Acl) {
                        #         option (google.api.http).get = "/v2/acls/{resource=**}:getAcl";
                        #       }
                        #       ...
                        #     }
                      "root": "A String", # If non-empty specifies a path under which inherited HTTP paths
                          # are rooted.
                      "name": "A String", # The fully qualified name of the API which is included.
                    },
                  ],
                  "syntax": "A String", # The source syntax of the service.
                  "version": "A String", # A version string for this api. If specified, must have the form
                      # `major-version.minor-version`, as in `1.10`. If the minor version
                      # is omitted, it defaults to zero. If the entire version field is
                      # empty, the major version is derived from the package name, as
                      # outlined below. If the field is not empty, the version in the
                      # package name will be verified to be consistent with what is
                      # provided here.
                      #
                      # The versioning schema uses [semantic
                      # versioning](http://semver.org) where the major version number
                      # indicates a breaking change and the minor version an additive,
                      # non-breaking change. Both version numbers are signals to users
                      # what to expect from different versions, and should be carefully
                      # chosen based on the product plan.
                      #
                      # The major version is also reflected in the package name of the
                      # API, which must end in `v`, as in
                      # `google.feature.v1`. For major versions 0 and 1, the suffix can
                      # be omitted. Zero major versions must only be used for
                      # experimental, none-GA apis.
                  "options": [ # Any metadata attached to the API.
                    { # A protocol buffer option, which can be attached to a message, field,
                        # enumeration, etc.
                      "name": "A String", # 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"`.
                      "value": { # 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.
                        "a_key": "", # Properties of the object. Contains field @type with type URL.
                      },
                    },
                  ],
                  "methods": [ # The methods of this api, in unspecified order.
                    { # Method represents a method of an api.
                      "name": "A String", # The simple name of this method.
                      "requestStreaming": True or False, # If true, the request is streamed.
                      "responseTypeUrl": "A String", # The URL of the output message type.
                      "requestTypeUrl": "A String", # A URL of the input message type.
                      "responseStreaming": True or False, # If true, the response is streamed.
                      "syntax": "A String", # The source syntax of this method.
                      "options": [ # Any metadata attached to the method.
                        { # A protocol buffer option, which can be attached to a message, field,
                            # enumeration, etc.
                          "name": "A String", # 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"`.
                          "value": { # 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.
                            "a_key": "", # Properties of the object. Contains field @type with type URL.
                          },
                        },
                      ],
                    },
                  ],
                },
              ],
              "customError": { # Customize service error responses.  For example, list any service # Custom error configuration.
                  # specific protobuf types that can appear in error detail lists of
                  # error responses.
                  #
                  # Example:
                  #
                  #     custom_error:
                  #       types:
                  #       - google.foo.v1.CustomError
                  #       - google.foo.v1.AnotherError
                "rules": [ # The list of custom error rules that apply to individual API messages.
                    #
                    # **NOTE:** All service configuration rules follow "last one wins" order.
                  { # A custom error rule.
                    "isErrorType": True or False, # Mark this message as possible payload in error response.  Otherwise,
                        # objects of this type will be filtered when they appear in error payload.
                    "selector": "A String", # Selects messages to which this rule applies.
                        #
                        # Refer to selector for syntax details.
                  },
                ],
                "types": [ # The list of custom error detail types, e.g. 'google.foo.v1.CustomError'.
                  "A String",
                ],
              },
              "quota": { # Quota configuration helps to achieve fairness and budgeting in service # Quota configuration.
                  # 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
                "metricRules": [ # List of `MetricRule` definitions, each one mapping a selected method to one
                    # or more metrics.
                  { # Bind API methods to metrics. Binding a method to a metric causes that
                      # metric's configured quota behaviors to apply to the method call.
                    "metricCosts": { # 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.
                      "a_key": "A String",
                    },
                    "selector": "A String", # Selects the methods to which this rule applies.
                        #
                        # Refer to selector for syntax details.
                  },
                ],
                "limits": [ # List of `QuotaLimit` definitions for the service.
                  { # `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`.
                    "displayName": "A String", # 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.
                    "description": "A String", # 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`).
                    "defaultLimit": "A String", # 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.
                    "metric": "A String", # 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.
                    "values": { # Tiered limit values, currently only STANDARD is supported.
                      "a_key": "A String",
                    },
                    "maxLimit": "A String", # 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.
                    "duration": "A String", # 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.
                    "freeTier": "A String", # 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.
                    "unit": "A String", # 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:
                        #   * "/{project}" quota for a project
                        #
                        # Here are some examples:
                        # * "1/min/{project}" for quota per minute per project.
                        #
                        # 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.
                    "name": "A String", # Name of the quota limit. The name is used to refer to the limit when
                        # overriding the default limit on per-consumer basis.
                        #
                        # 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.
                  },
                ],
              },
              "visibility": { # `Visibility` defines restrictions for the visibility of service # API visibility configuration.
                  # elements.  Restrictions are specified using visibility labels
                  # (e.g., TRUSTED_TESTER) that are elsewhere linked to users and projects.
                  #
                  # Users and projects can have access to more than one visibility label. The
                  # effective visibility for multiple labels is the union of each label's
                  # elements, plus any unrestricted elements.
                  #
                  # If an element and its parents have no restrictions, visibility is
                  # unconditionally granted.
                  #
                  # Example:
                  #
                  #     visibility:
                  #       rules:
                  #       - selector: google.calendar.Calendar.EnhancedSearch
                  #         restriction: TRUSTED_TESTER
                  #       - selector: google.calendar.Calendar.Delegate
                  #         restriction: GOOGLE_INTERNAL
                  #
                  # Here, all methods are publicly visible except for the restricted methods
                  # EnhancedSearch and Delegate.
                "rules": [ # A list of visibility rules that apply to individual API elements.
                    #
                    # **NOTE:** All service configuration rules follow "last one wins" order.
                  { # A visibility rule provides visibility configuration for an individual API
                      # element.
                    "restriction": "A String", # A comma-separated list of visibility labels that apply to the `selector`.
                        # Any of the listed labels can be used to grant the visibility.
                        #
                        # If a rule has multiple labels, removing one of the labels but not all of
                        # them can break clients.
                        #
                        # Example:
                        #
                        #     visibility:
                        #       rules:
                        #       - selector: google.calendar.Calendar.EnhancedSearch
                        #         restriction: GOOGLE_INTERNAL, TRUSTED_TESTER
                        #
                        # Removing GOOGLE_INTERNAL from this restriction will break clients that
                        # rely on this method and only had access to it through GOOGLE_INTERNAL.
                    "selector": "A String", # Selects methods, messages, fields, enums, etc. to which this rule applies.
                        #
                        # Refer to selector for syntax details.
                  },
                ],
              },
              "metrics": [ # Defines the metrics used by this service.
                { # Defines a metric type and its schema. Once a metric descriptor is created,
                    # deleting or altering it stops data collection and makes the metric type's
                    # existing data unusable.
                  "displayName": "A String", # A concise name for the metric, which can be displayed in user interfaces.
                      # Use sentence case without an ending period, for example "Request count".
                  "name": "A String", # The resource name of the metric descriptor. Depending on the
                      # implementation, the name typically includes: (1) the parent resource name
                      # that defines the scope of the metric type or of its data; and (2) the
                      # metric's URL-encoded type, which also appears in the `type` field of this
                      # descriptor. For example, following is the resource name of a custom
                      # metric within the GCP project `my-project-id`:
                      #
                      #     "projects/my-project-id/metricDescriptors/custom.googleapis.com%2Finvoice%2Fpaid%2Famount"
                  "metricKind": "A String", # Whether the metric records instantaneous values, changes to a value, etc.
                      # Some combinations of `metric_kind` and `value_type` might not be supported.
                  "valueType": "A String", # Whether the measurement is an integer, a floating-point number, etc.
                      # Some combinations of `metric_kind` and `value_type` might not be supported.
                  "labels": [ # The set of labels that can be used to describe a specific
                      # instance of this metric type. For example, the
                      # `appengine.googleapis.com/http/server/response_latencies` metric
                      # type has a label for the HTTP response code, `response_code`, so
                      # you can look at latencies for successful responses or just
                      # for responses that failed.
                    { # A description of a label.
                      "valueType": "A String", # The type of data that can be assigned to the label.
                      "description": "A String", # A human-readable description for the label.
                      "key": "A String", # The label key.
                    },
                  ],
                  "type": "A String", # The metric type, including its DNS name prefix. The type is not
                      # URL-encoded.  All user-defined custom metric types have the DNS name
                      # `custom.googleapis.com`.  Metric types should use a natural hierarchical
                      # grouping. For example:
                      #
                      #     "custom.googleapis.com/invoice/paid/amount"
                      #     "appengine.googleapis.com/http/server/response_latencies"
                  "unit": "A String", # The unit in which the metric value is reported. It is only applicable
                      # if the `value_type` is `INT64`, `DOUBLE`, or `DISTRIBUTION`. The
                      # supported units are a subset of [The Unified Code for Units of
                      # Measure](http://unitsofmeasure.org/ucum.html) standard:
                      #
                      # **Basic units (UNIT)**
                      #
                      # * `bit`   bit
                      # * `By`    byte
                      # * `s`     second
                      # * `min`   minute
                      # * `h`     hour
                      # * `d`     day
                      #
                      # **Prefixes (PREFIX)**
                      #
                      # * `k`     kilo    (10**3)
                      # * `M`     mega    (10**6)
                      # * `G`     giga    (10**9)
                      # * `T`     tera    (10**12)
                      # * `P`     peta    (10**15)
                      # * `E`     exa     (10**18)
                      # * `Z`     zetta   (10**21)
                      # * `Y`     yotta   (10**24)
                      # * `m`     milli   (10**-3)
                      # * `u`     micro   (10**-6)
                      # * `n`     nano    (10**-9)
                      # * `p`     pico    (10**-12)
                      # * `f`     femto   (10**-15)
                      # * `a`     atto    (10**-18)
                      # * `z`     zepto   (10**-21)
                      # * `y`     yocto   (10**-24)
                      # * `Ki`    kibi    (2**10)
                      # * `Mi`    mebi    (2**20)
                      # * `Gi`    gibi    (2**30)
                      # * `Ti`    tebi    (2**40)
                      #
                      # **Grammar**
                      #
                      # The grammar includes the dimensionless unit `1`, such as `1/s`.
                      #
                      # The grammar also includes these connectors:
                      #
                      # * `/`    division (as an infix operator, e.g. `1/s`).
                      # * `.`    multiplication (as an infix operator, e.g. `GBy.d`)
                      #
                      # The grammar for a unit is as follows:
                      #
                      #     Expression = Component { "." Component } { "/" Component } ;
                      #
                      #     Component = [ PREFIX ] UNIT [ Annotation ]
                      #               | Annotation
                      #               | "1"
                      #               ;
                      #
                      #     Annotation = "{" NAME "}" ;
                      #
                      # Notes:
                      #
                      # * `Annotation` is just a comment if it follows a `UNIT` and is
                      #    equivalent to `1` if it is used alone. For examples,
                      #    `{requests}/s == 1/s`, `By{transmitted}/s == By/s`.
                      # * `NAME` is a sequence of non-blank printable ASCII characters not
                      #    containing '{' or '}'.
                  "description": "A String", # A detailed description of the metric, which can be used in documentation.
                },
              ],
              "enums": [ # A list of all enum types included in this API service.  Enums
                  # referenced directly or indirectly by the `apis` are automatically
                  # included.  Enums which are not referenced but shall be included
                  # should be listed here by name. Example:
                  #
                  #     enums:
                  #     - name: google.someapi.v1.SomeEnum
                { # Enum type definition.
                  "syntax": "A String", # The source syntax.
                  "sourceContext": { # `SourceContext` represents information about the source of a # The source context.
                      # protobuf element, like the file in which it is defined.
                    "fileName": "A String", # The path-qualified name of the .proto file that contained the associated
                        # protobuf element.  For example: `"google/protobuf/source_context.proto"`.
                  },
                  "options": [ # Protocol buffer options.
                    { # A protocol buffer option, which can be attached to a message, field,
                        # enumeration, etc.
                      "name": "A String", # 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"`.
                      "value": { # 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.
                        "a_key": "", # Properties of the object. Contains field @type with type URL.
                      },
                    },
                  ],
                  "name": "A String", # Enum type name.
                  "enumvalue": [ # Enum value definitions.
                    { # Enum value definition.
                      "number": 42, # Enum value number.
                      "name": "A String", # Enum value name.
                      "options": [ # Protocol buffer options.
                        { # A protocol buffer option, which can be attached to a message, field,
                            # enumeration, etc.
                          "name": "A String", # 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"`.
                          "value": { # 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.
                            "a_key": "", # Properties of the object. Contains field @type with type URL.
                          },
                        },
                      ],
                    },
                  ],
                },
              ],
              "types": [ # A list of all proto message types included in this API service.
                  # Types referenced directly or indirectly by the `apis` are
                  # automatically included.  Messages which are not referenced but
                  # shall be included, such as types used by the `google.protobuf.Any` type,
                  # should be listed here by name. Example:
                  #
                  #     types:
                  #     - name: google.protobuf.Int32
                { # A protocol buffer message type.
                  "oneofs": [ # The list of types appearing in `oneof` definitions in this type.
                    "A String",
                  ],
                  "name": "A String", # The fully qualified message name.
                  "fields": [ # The list of fields.
                    { # A single field of a message type.
                      "kind": "A String", # The field type.
                      "oneofIndex": 42, # The index of the field type in `Type.oneofs`, for message or enumeration
                          # types. The first type has index 1; zero means the type is not in the list.
                      "typeUrl": "A String", # The field type URL, without the scheme, for message or enumeration
                          # types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`.
                      "name": "A String", # The field name.
                      "defaultValue": "A String", # The string value of the default value of this field. Proto2 syntax only.
                      "jsonName": "A String", # The field JSON name.
                      "number": 42, # The field number.
                      "cardinality": "A String", # The field cardinality.
                      "options": [ # The protocol buffer options.
                        { # A protocol buffer option, which can be attached to a message, field,
                            # enumeration, etc.
                          "name": "A String", # 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"`.
                          "value": { # 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.
                            "a_key": "", # Properties of the object. Contains field @type with type URL.
                          },
                        },
                      ],
                      "packed": True or False, # Whether to use alternative packed wire representation.
                    },
                  ],
                  "syntax": "A String", # The source syntax.
                  "sourceContext": { # `SourceContext` represents information about the source of a # The source context.
                      # protobuf element, like the file in which it is defined.
                    "fileName": "A String", # The path-qualified name of the .proto file that contained the associated
                        # protobuf element.  For example: `"google/protobuf/source_context.proto"`.
                  },
                  "options": [ # The protocol buffer options.
                    { # A protocol buffer option, which can be attached to a message, field,
                        # enumeration, etc.
                      "name": "A String", # 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"`.
                      "value": { # 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.
                        "a_key": "", # Properties of the object. Contains field @type with type URL.
                      },
                    },
                  ],
                },
              ],
              "logging": { # Logging configuration of the service. # Logging configuration.
                  #
                  # The following example shows how to configure logs to be sent to the
                  # producer and consumer projects. In the example, the `activity_history`
                  # log is sent to both the producer and consumer projects, whereas the
                  # `purchase_history` log is only sent to the producer project.
                  #
                  #     monitored_resources:
                  #     - type: library.googleapis.com/branch
                  #       labels:
                  #       - key: /city
                  #         description: The city where the library branch is located in.
                  #       - key: /name
                  #         description: The name of the branch.
                  #     logs:
                  #     - name: activity_history
                  #       labels:
                  #       - key: /customer_id
                  #     - name: purchase_history
                  #     logging:
                  #       producer_destinations:
                  #       - monitored_resource: library.googleapis.com/branch
                  #         logs:
                  #         - activity_history
                  #         - purchase_history
                  #       consumer_destinations:
                  #       - monitored_resource: library.googleapis.com/branch
                  #         logs:
                  #         - activity_history
                "producerDestinations": [ # Logging configurations for sending logs to the producer project.
                    # There can be multiple producer destinations, each one must have a
                    # different monitored resource type. A log can be used in at most
                    # one producer destination.
                  { # Configuration of a specific logging destination (the producer project
                      # or the consumer project).
                    "monitoredResource": "A String", # The monitored resource type. The type must be defined in the
                        # Service.monitored_resources section.
                    "logs": [ # Names of the logs to be sent to this destination. Each name must
                        # be defined in the Service.logs section. If the log name is
                        # not a domain scoped name, it will be automatically prefixed with
                        # the service name followed by "/".
                      "A String",
                    ],
                  },
                ],
                "consumerDestinations": [ # Logging configurations for sending logs to the consumer project.
                    # There can be multiple consumer destinations, each one must have a
                    # different monitored resource type. A log can be used in at most
                    # one consumer destination.
                  { # Configuration of a specific logging destination (the producer project
                      # or the consumer project).
                    "monitoredResource": "A String", # The monitored resource type. The type must be defined in the
                        # Service.monitored_resources section.
                    "logs": [ # Names of the logs to be sent to this destination. Each name must
                        # be defined in the Service.logs section. If the log name is
                        # not a domain scoped name, it will be automatically prefixed with
                        # the service name followed by "/".
                      "A String",
                    ],
                  },
                ],
              },
              "name": "A String", # The DNS address at which this service is available,
                  # e.g. `calendar.googleapis.com`.
              "documentation": { # `Documentation` provides the information for describing a service. # Additional API documentation.
                  #
                  # Example:
                  # documentation:
                  #   summary: >
                  #     The Google Calendar API gives access
                  #     to most calendar features.
                  #   pages:
                  #   - name: Overview
                  #     content: (== include google/foo/overview.md ==)
                  #   - name: Tutorial
                  #     content: (== include google/foo/tutorial.md ==)
                  #     subpages;
                  #     - name: Java
                  #       content: (== include google/foo/tutorial_java.md ==)
                  #   rules:
                  #   - selector: google.calendar.Calendar.Get
                  #     description: >
                  #       ...
                  #   - selector: google.calendar.Calendar.Put
                  #     description: >
                  #       ...
                  #
                  # Documentation is provided in markdown syntax. In addition to
                  # standard markdown features, definition lists, tables and fenced
                  # code blocks are supported. Section headers can be provided and are
                  # interpreted relative to the section nesting of the context where
                  # a documentation fragment is embedded.
                  #
                  # Documentation from the IDL is merged with documentation defined
                  # via the config at normalization time, where documentation provided
                  # by config rules overrides IDL provided.
                  #
                  # A number of constructs specific to the API platform are supported
                  # in documentation text.
                  #
                  # In order to reference a proto element, the following
                  # notation can be used:
                  # [fully.qualified.proto.name][]
                  # To override the display text used for the link, this can be used:
                  # [display text][fully.qualified.proto.name]
                  # Text can be excluded from doc using the following notation:
                  # (-- internal comment --)
                  # Comments can be made conditional using a visibility label. The below
                  # text will be only rendered if the `BETA` label is available:
                  # (--BETA: comment for BETA users --)
                  # A few directives are available in documentation. Note that
                  # directives must appear on a single line to be properly
                  # identified. The `include` directive includes a markdown file from
                  # an external source:
                  # (== include path/to/file ==)
                  # The `resource_for` directive marks a message to be the resource of
                  # a collection in REST view. If it is not specified, tools attempt
                  # to infer the resource from the operations in a collection:
                  # (== resource_for v1.shelves.books ==)
                  # The directive `suppress_warning` does not directly affect documentation
                  # and is documented together with service config validation.
                "rules": [ # A list of documentation rules that apply to individual API elements.
                    #
                    # **NOTE:** All service configuration rules follow "last one wins" order.
                  { # A documentation rule provides information about individual API elements.
                    "description": "A String", # Description of the selected API(s).
                    "deprecationDescription": "A String", # Deprecation description of the selected element(s). It can be provided if an
                        # element is marked as `deprecated`.
                    "selector": "A String", # The selector is a comma-separated list of patterns. Each pattern is a
                        # qualified name of the element which may end in "*", indicating a wildcard.
                        # Wildcards are only allowed at the end and for a whole component of the
                        # qualified name, i.e. "foo.*" is ok, but not "foo.b*" or "foo.*.bar". To
                        # specify a default for all applicable elements, the whole pattern "*"
                        # is used.
                  },
                ],
                "documentationRootUrl": "A String", # The URL to the root of documentation.
                "overview": "A String", # Declares a single overview page. For example:
                    # documentation:
                    #   summary: ...
                    #   overview: (== include overview.md ==)
                    #
                    # This is a shortcut for the following declaration (using pages style):
                    # documentation:
                    #   summary: ...
                    #   pages:
                    #   - name: Overview
                    #     content: (== include overview.md ==)
                    #
                    # Note: you cannot specify both `overview` field and `pages` field.
                "pages": [ # The top level pages for the documentation set.
                  { # Represents a documentation page. A page can contain subpages to represent
                      # nested documentation set structure.
                    "content": "A String", # The Markdown content of the page. You can use (== include {path} ==)
                        # to include content from a Markdown file.
                    "subpages": [ # Subpages of this page. The order of subpages specified here will be
                        # honored in the generated docset.
                      # Object with schema name: Page
                    ],
                    "name": "A String", # The name of the page. It will be used as an identity of the page to
                        # generate URI of the page, text of the link to this page in navigation,
                        # etc. The full page name (start from the root page name to this page
                        # concatenated with `.`) can be used as reference to the page in your
                        # documentation. For example:
                        # pages:
                        # - name: Tutorial
                        #   content: (== include tutorial.md ==)
                        #   subpages:
                        #   - name: Java
                        #     content: (== include tutorial_java.md ==)
                        #
                        # You can reference `Java` page using Markdown reference link syntax:
                        # `Java`.
                  },
                ],
                "summary": "A String", # A short summary of what the service does. Can only be provided by
                    # plain text.
              },
              "sourceInfo": { # Source information used to create a Service Config # Output only. The source information for this configuration if available.
                "sourceFiles": [ # All files used during config generation.
                  {
                    "a_key": "", # Properties of the object. Contains field @type with type URL.
                  },
                ],
              },
              "systemTypes": [ # 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
                  # show up in the generated discovery doc. This field should only be used
                  # to define system APIs in ESF.
                { # A protocol buffer message type.
                  "oneofs": [ # The list of types appearing in `oneof` definitions in this type.
                    "A String",
                  ],
                  "name": "A String", # The fully qualified message name.
                  "fields": [ # The list of fields.
                    { # A single field of a message type.
                      "kind": "A String", # The field type.
                      "oneofIndex": 42, # The index of the field type in `Type.oneofs`, for message or enumeration
                          # types. The first type has index 1; zero means the type is not in the list.
                      "typeUrl": "A String", # The field type URL, without the scheme, for message or enumeration
                          # types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`.
                      "name": "A String", # The field name.
                      "defaultValue": "A String", # The string value of the default value of this field. Proto2 syntax only.
                      "jsonName": "A String", # The field JSON name.
                      "number": 42, # The field number.
                      "cardinality": "A String", # The field cardinality.
                      "options": [ # The protocol buffer options.
                        { # A protocol buffer option, which can be attached to a message, field,
                            # enumeration, etc.
                          "name": "A String", # 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"`.
                          "value": { # 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.
                            "a_key": "", # Properties of the object. Contains field @type with type URL.
                          },
                        },
                      ],
                      "packed": True or False, # Whether to use alternative packed wire representation.
                    },
                  ],
                  "syntax": "A String", # The source syntax.
                  "sourceContext": { # `SourceContext` represents information about the source of a # The source context.
                      # protobuf element, like the file in which it is defined.
                    "fileName": "A String", # The path-qualified name of the .proto file that contained the associated
                        # protobuf element.  For example: `"google/protobuf/source_context.proto"`.
                  },
                  "options": [ # The protocol buffer options.
                    { # A protocol buffer option, which can be attached to a message, field,
                        # enumeration, etc.
                      "name": "A String", # 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"`.
                      "value": { # 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.
                        "a_key": "", # Properties of the object. Contains field @type with type URL.
                      },
                    },
                  ],
                },
              ],
              "context": { # `Context` defines which contexts an API requests. # Context configuration.
                  #
                  # Example:
                  #
                  #     context:
                  #       rules:
                  #       - selector: "*"
                  #         requested:
                  #         - google.rpc.context.ProjectContext
                  #         - google.rpc.context.OriginContext
                  #
                  # The above specifies that all methods in the API request
                  # `google.rpc.context.ProjectContext` and
                  # `google.rpc.context.OriginContext`.
                  #
                  # Available context types are defined in package
                  # `google.rpc.context`.
                "rules": [ # A list of RPC context rules that apply to individual API methods.
                    #
                    # **NOTE:** All service configuration rules follow "last one wins" order.
                  { # A context rule provides information about the context for an individual API
                      # element.
                    "provided": [ # A list of full type names of provided contexts.
                      "A String",
                    ],
                    "requested": [ # A list of full type names of requested contexts.
                      "A String",
                    ],
                    "selector": "A String", # Selects the methods to which this rule applies.
                        #
                        # Refer to selector for syntax details.
                  },
                ],
              },
              "endpoints": [ # Configuration for network endpoints.  If this is empty, then an endpoint
                  # with the same name as the service is automatically generated to service all
                  # defined APIs.
                { # `Endpoint` describes a network endpoint that serves a set of APIs.
                    # A service may expose any number of endpoints, and all endpoints share the
                    # same service configuration, such as quota configuration and monitoring
                    # configuration.
                    #
                    # 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
                    #       allow_cors: true
                  "features": [ # The list of features enabled on this endpoint.
                    "A String",
                  ],
                  "apis": [ # The list of APIs served by this endpoint.
                      #
                      # If no APIs are specified this translates to "all APIs" exported by the
                      # service, as defined in the top-level service configuration.
                    "A String",
                  ],
                  "allowCors": True or False, # Allowing
                      # [CORS](https://en.wikipedia.org/wiki/Cross-origin_resource_sharing), aka
                      # cross-domain traffic, would allow the backends served from this endpoint to
                      # receive and respond to HTTP OPTIONS requests. The response will be used by
                      # the browser to determine whether the subsequent cross-origin request is
                      # allowed to proceed.
                  "name": "A String", # The canonical name of this endpoint.
                  "target": "A String", # 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".
                  "aliases": [ # 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.
                    "A String",
                  ],
                },
              ],
              "experimental": { # Experimental service configuration. These configuration options can # Experimental configuration.
                  # only be used by whitelisted users.
                "authorization": { # Configuration of authorization. # Authorization configuration.
                    #
                    # This section determines the authorization provider, if unspecified, then no
                    # authorization check will be done.
                    #
                    # Example:
                    #
                    #     experimental:
                    #       authorization:
                    #         provider: firebaserules.googleapis.com
                  "provider": "A String", # The name of the authorization provider, such as
                      # firebaserules.googleapis.com.
                },
              },
            },
          },
        ],
        "nextPageToken": "A String", # Token that can be passed to `ListEnabledServices` to resume a paginated
            # query.
      }

`list_next(previous_request, previous_response)`

    Retrieves the next page of results.

    Args:
      previous_request: The request for the previous page. (required)
      previous_response: The response from the request for the previous page. (required)

    Returns:
      A request object that you can call 'execute()' on to request the next
      page. Returns None if there are no more items in the collection.