googleapis/build/src/apis/servicemanagement/v1.d.ts

Google APIs Client Library for Node.js

/**
 * Copyright 2015 Google Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import { AxiosPromise } from 'axios';
import { GoogleApis } from '../..';
import { BodyResponseCallback, GlobalOptions, MethodOptions } from '../../lib/api';
/**
 * Google Service Management API
 *
 * Google Service Management allows service producers to publish their services
 * on Google Cloud Platform so that they can be discovered and used by service
 * consumers.
 *
 * @example
 * const google = require('googleapis');
 * const servicemanagement = google.servicemanagement('v1');
 *
 * @namespace servicemanagement
 * @type {Function}
 * @version v1
 * @variation v1
 * @param {object=} options Options for Servicemanagement
 */
export declare class Servicemanagement {
    _options: GlobalOptions;
    google: GoogleApis;
    root: this;
    operations: Resource$Operations;
    services: Resource$Services;
    constructor(options: GlobalOptions, google: GoogleApis);
    getRoot(): this;
}
/**
 * Generated advice about this change, used for providing more information about
 * how a change will affect the existing service.
 */
export interface Schema$Advice {
    /**
     * Useful description for why this advice was applied and what actions should
     * be taken to mitigate any implied risks.
     */
    description: string;
}
/**
 * Api is a light-weight descriptor for an API Interface.  Interfaces are also
 * described as "protocol buffer services" in some contexts, such as
 * by the "service" keyword in a .proto file, but they are different
 * from API Services, which represent a concrete implementation of an interface
 * as opposed to simply a description of methods and bindings. They are also
 * sometimes simply referred to as "APIs" in other contexts, such as
 * the name of this message itself. See
 * https://cloud.google.com/apis/design/glossary for detailed terminology.
 */
export interface Schema$Api {
    /**
     * The methods of this interface, in unspecified order.
     */
    methods: Schema$Method[];
    /**
     * Included interfaces. See Mixin.
     */
    mixins: Schema$Mixin[];
    /**
     * The fully qualified name of this interface, including package name followed
     * by the interface's simple name.
     */
    name: string;
    /**
     * Any metadata attached to the interface.
     */
    options: Schema$Option[];
    /**
     * Source context for the protocol buffer service represented by this message.
     */
    sourceContext: Schema$SourceContext;
    /**
     * The source syntax of the service.
     */
    syntax: string;
    /**
     * A version string for this interface. 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
     * interface, which must end in `v<major-version>`, 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, non-GA interfaces.
     */
    version: string;
}
/**
 * Specifies the audit configuration for a service. The configuration determines
 * which permission types are logged, and what identities, if any, are exempted
 * from logging. An AuditConfig must have one or more AuditLogConfigs.  If there
 * are AuditConfigs for both `allServices` and a specific service, the union of
 * the two AuditConfigs is used for that service: the log_types specified in
 * each AuditConfig are enabled, and the exempted_members in each AuditLogConfig
 * are exempted.  Example Policy with multiple AuditConfigs:      {
 * "audit_configs": [         {           "service":
 * "allServices"           "audit_log_configs": [ {
 * "log_type": "DATA_READ", "exempted_members": [
 * "user:foo@gmail.com"               ]             },             {
 * "log_type": "DATA_WRITE",             },             {
 * "log_type": "ADMIN_READ",             }           ] }, {
 * "service": "fooservice.googleapis.com"
 * "audit_log_configs": [             { "log_type":
 * "DATA_READ",             },             { "log_type":
 * "DATA_WRITE",               "exempted_members": [
 * "user:bar@gmail.com"               ]             }           ] } ]
 * }  For fooservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ
 * logging. It also exempts foo@gmail.com from DATA_READ logging, and
 * bar@gmail.com from DATA_WRITE logging.
 */
export interface Schema$AuditConfig {
    /**
     * The configuration for logging of each type of permission.
     */
    auditLogConfigs: Schema$AuditLogConfig[];
    /**
     * Specifies a service that will be enabled for audit logging. For example,
     * `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a
     * special value that covers all services.
     */
    service: string;
}
/**
 * Provides the configuration for logging a type of permissions. Example:      {
 * "audit_log_configs": [         {           "log_type":
 * "DATA_READ",           "exempted_members": [
 * "user:foo@gmail.com"           ]         },         {
 * "log_type": "DATA_WRITE",         }       ]     }  This
 * enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting
 * foo@gmail.com from DATA_READ logging.
 */
export interface Schema$AuditLogConfig {
    /**
     * Specifies the identities that do not cause logging for this type of
     * permission. Follows the same format of Binding.members.
     */
    exemptedMembers: string[];
    /**
     * The log type that this config enables.
     */
    logType: string;
}
/**
 * `Authentication` defines the authentication configuration for an API. Example
 * for an API targeted for external use:      name: calendar.googleapis.com
 * authentication:       providers:       - id: google_calendar_auth jwks_uri:
 * https://www.googleapis.com/oauth2/v1/certs         issuer:
 * https://securetoken.google.com       rules:       - selector: "*"
 * requirements:           provider_id: google_calendar_auth
 */
export interface Schema$Authentication {
    /**
     * Defines a set of authentication providers that a service supports.
     */
    providers: Schema$AuthProvider[];
    /**
     * A list of authentication rules that apply to individual API methods.
     * **NOTE:** All service configuration rules follow "last one wins"
     * order.
     */
    rules: Schema$AuthenticationRule[];
}
/**
 * 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.
 */
export interface Schema$AuthenticationRule {
    /**
     * If true, the service accepts API keys without any other credential.
     */
    allowWithoutCredential: boolean;
    /**
     * Configuration for custom authentication.
     */
    customAuth: Schema$CustomAuthRequirements;
    /**
     * The requirements for OAuth credentials.
     */
    oauth: Schema$OAuthRequirements;
    /**
     * Requirements for additional authentication providers.
     */
    requirements: Schema$AuthRequirement[];
    /**
     * Selects the methods to which this rule applies.  Refer to selector for
     * syntax details.
     */
    selector: string;
}
/**
 * Configuration of authorization.  This section determines the authorization
 * provider, if unspecified, then no authorization check will be done.  Example:
 * experimental:       authorization:         provider:
 * firebaserules.googleapis.com
 */
export interface Schema$AuthorizationConfig {
    /**
     * The name of the authorization provider, such as
     * firebaserules.googleapis.com.
     */
    provider: string;
}
/**
 * Configuration for an anthentication provider, including support for [JSON Web
 * Token (JWT)](https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32).
 */
export interface Schema$AuthProvider {
    /**
     * The list of JWT
     * [audiences](https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32#section-4.1.3).
     * that are allowed to access. A JWT containing any of these audiences will 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
     */
    audiences: string;
    /**
     * Redirect URL if JWT token is required but no present or is expired.
     * Implement authorizationUrl of securityDefinitions in OpenAPI spec.
     */
    authorizationUrl: string;
    /**
     * The unique identifier of the auth provider. It will be referred to by
     * `AuthRequirement.provider_id`.  Example: "bookstore_auth".
     */
    id: 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
     */
    issuer: 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
     */
    jwksUri: string;
}
/**
 * User-defined authentication requirements, including support for [JSON Web
 * Token (JWT)](https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32).
 */
export interface Schema$AuthRequirement {
    /**
     * 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
     */
    audiences: string;
    /**
     * id from authentication provider.  Example:      provider_id: bookstore_auth
     */
    providerId: string;
}
/**
 * `Backend` defines the backend configuration for a service.
 */
export interface Schema$Backend {
    /**
     * A list of API backend rules that apply to individual API methods. **NOTE:**
     * All service configuration rules follow "last one wins" order.
     */
    rules: Schema$BackendRule[];
}
/**
 * A backend rule provides configuration for an individual API element.
 */
export interface Schema$BackendRule {
    /**
     * The address of the API backend.
     */
    address: string;
    /**
     * The number of seconds to wait for a response from a request.  The default
     * deadline for gRPC is infinite (no deadline) and HTTP requests is 5 seconds.
     */
    deadline: number;
    /**
     * Minimum deadline in seconds needed for this method. Calls having deadline
     * value lower than this will be rejected.
     */
    minDeadline: number;
    /**
     * Selects the methods to which this rule applies.  Refer to selector for
     * syntax details.
     */
    selector: string;
}
/**
 * Billing related configuration of the service.  The following example shows
 * how to configure monitored resources and metrics for billing:
 * 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/borrowed_count metric_kind:
 * DELTA       value_type: INT64     billing:       consumer_destinations: -
 * monitored_resource: library.googleapis.com/branch         metrics:         -
 * library.googleapis.com/book/borrowed_count
 */
export interface Schema$Billing {
    /**
     * Billing configurations for sending metrics to the consumer project. There
     * can be multiple consumer destinations per service, each one must have a
     * different monitored resource type. A metric can be used in at most one
     * consumer destination.
     */
    consumerDestinations: Schema$BillingDestination[];
}
/**
 * Configuration of a specific billing destination (Currently only support bill
 * against consumer project).
 */
export interface Schema$BillingDestination {
    /**
     * Names of the metrics to report to this billing destination. Each name must
     * be defined in Service.metrics section.
     */
    metrics: string[];
    /**
     * The monitored resource type. The type must be defined in
     * Service.monitored_resources section.
     */
    monitoredResource: string;
}
/**
 * Associates `members` with a `role`.
 */
export interface Schema$Binding {
    /**
     * Specifies the identities requesting access for a Cloud Platform resource.
     * `members` can have the following values:  * `allUsers`: A special
     * identifier that represents anyone who is    on the internet; with or
     * without a Google account.  * `allAuthenticatedUsers`: A special identifier
     * that represents anyone    who is authenticated with a Google account or a
     * service account.  * `user:{emailid}`: An email address that represents a
     * specific Google    account. For example, `alice@gmail.com` or
     * `joe@example.com`.   * `serviceAccount:{emailid}`: An email address that
     * represents a service    account. For example,
     * `my-other-app@appspot.gserviceaccount.com`.  * `group:{emailid}`: An email
     * address that represents a Google group.    For example,
     * `admins@example.com`.   * `domain:{domain}`: A Google Apps domain name that
     * represents all the    users of that domain. For example, `google.com` or
     * `example.com`.
     */
    members: string[];
    /**
     * Role that is assigned to `members`. For example, `roles/viewer`,
     * `roles/editor`, or `roles/owner`. Required
     */
    role: string;
}
/**
 * Change report associated with a particular service configuration.  It
 * contains a list of ConfigChanges based on the comparison between two service
 * configurations.
 */
export interface Schema$ChangeReport {
    /**
     * List of changes between two service configurations. The changes will be
     * alphabetically sorted based on the identifier of each change. A
     * ConfigChange identifier is a dot separated path to the configuration.
     * Example:
     * visibility.rules[selector='LibraryService.CreateBook'].restriction
     */
    configChanges: Schema$ConfigChange[];
}
/**
 * Output generated from semantically comparing two versions of a service
 * configuration.  Includes detailed information about a field that have changed
 * with applicable advice about potential consequences for the change, such as
 * backwards-incompatibility.
 */
export interface Schema$ConfigChange {
    /**
     * Collection of advice provided for this change, useful for determining the
     * possible impact of this change.
     */
    advices: Schema$Advice[];
    /**
     * The type for this change, either ADDED, REMOVED, or MODIFIED.
     */
    changeType: string;
    /**
     * Object hierarchy path to the change, with levels separated by a '.'
     * character. For repeated fields, an applicable unique identifier field is
     * used for the index (usually selector, name, or id). For maps, the term
     * 'key' is used. If the field has no unique identifier, the numeric
     * index is used. Examples: -
     * visibility.rules[selector=="google.LibraryService.CreateBook"].restriction
     * -
     * quota.metric_rules[selector=="google"].metric_costs[key=="reads"].value
     * - logging.producer_destinations[0]
     */
    element: string;
    /**
     * Value of the changed object in the new Service configuration, in JSON
     * format. This field will not be populated if ChangeType == REMOVED.
     */
    newValue: string;
    /**
     * Value of the changed object in the old Service configuration, in JSON
     * format. This field will not be populated if ChangeType == ADDED.
     */
    oldValue: string;
}
/**
 * Generic specification of a source configuration file
 */
export interface Schema$ConfigFile {
    /**
     * The bytes that constitute the file.
     */
    fileContents: string;
    /**
     * The file name of the configuration file (full or relative path).
     */
    filePath: string;
    /**
     * The type of configuration file this represents.
     */
    fileType: string;
}
/**
 * Represents a service configuration with its name and id.
 */
export interface Schema$ConfigRef {
    /**
     * Resource name of a service config. It must have the following format:
     * "services/{service name}/configs/{config id}".
     */
    name: string;
}
/**
 * Represents a source file which is used to generate the service configuration
 * defined by `google.api.Service`.
 */
export interface Schema$ConfigSource {
    /**
     * Set of source configuration files that are used to generate a service
     * configuration (`google.api.Service`).
     */
    files: Schema$ConfigFile[];
    /**
     * 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.
     */
    id: string;
}
/**
 * `Context` defines which contexts an API requests.  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`.  This
 * also provides mechanism to whitelist any protobuf message extension that can
 * be sent in grpc metadata using “x-goog-ext-<extension_id>-bin” and
 * “x-goog-ext-<extension_id>-jspb” format. For example, list any service
 * specific protobuf types that can appear in grpc metadata as follows in your
 * yaml file:  Example:      context:       rules:        - selector:
 * "google.example.library.v1.LibraryService.CreateBook"
 * allowed_request_extensions:          - google.foo.v1.NewExtension
 * allowed_response_extensions:          - google.foo.v1.NewExtension  You can
 * also specify extension ID instead of fully qualified extension name here.
 */
export interface Schema$Context {
    /**
     * A list of RPC context rules that apply to individual API methods. **NOTE:**
     * All service configuration rules follow "last one wins" order.
     */
    rules: Schema$ContextRule[];
}
/**
 * A context rule provides information about the context for an individual API
 * element.
 */
export interface Schema$ContextRule {
    /**
     * A list of full type names or extension IDs of extensions allowed in grpc
     * side channel from client to backend.
     */
    allowedRequestExtensions: string[];
    /**
     * A list of full type names or extension IDs of extensions allowed in grpc
     * side channel from backend to client.
     */
    allowedResponseExtensions: string[];
    /**
     * A list of full type names of provided contexts.
     */
    provided: string[];
    /**
     * A list of full type names of requested contexts.
     */
    requested: string[];
    /**
     * Selects the methods to which this rule applies.  Refer to selector for
     * syntax details.
     */
    selector: string;
}
/**
 * Selects and configures the service controller used by the service.  The
 * service controller handles features like abuse, quota, billing, logging,
 * monitoring, etc.
 */
export interface Schema$Control {
    /**
     * The service control environment to use. If empty, no control plane feature
     * (like quota and billing) will be enabled.
     */
    environment: string;
}
/**
 * Configuration for a custom authentication provider.
 */
export interface Schema$CustomAuthRequirements {
    /**
     * A configuration string containing connection information for the
     * authentication provider, typically formatted as a SmartService string
     * (go/smartservice).
     */
    provider: string;
}
/**
 * Customize service error responses.  For example, list any service 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
 */
export interface Schema$CustomError {
    /**
     * The list of custom error rules that apply to individual API messages.
     * **NOTE:** All service configuration rules follow "last one wins"
     * order.
     */
    rules: Schema$CustomErrorRule[];
    /**
     * The list of custom error detail types, e.g.
     * 'google.foo.v1.CustomError'.
     */
    types: string[];
}
/**
 * A custom error rule.
 */
export interface Schema$CustomErrorRule {
    /**
     * Mark this message as possible payload in error response.  Otherwise,
     * objects of this type will be filtered when they appear in error payload.
     */
    isErrorType: boolean;
    /**
     * Selects messages to which this rule applies.  Refer to selector for syntax
     * details.
     */
    selector: string;
}
/**
 * A custom pattern is used for defining custom HTTP verb.
 */
export interface Schema$CustomHttpPattern {
    /**
     * The name of this custom HTTP verb.
     */
    kind: string;
    /**
     * The path matched by this custom verb.
     */
    path: string;
}
/**
 * Strategy used to delete a service. This strategy is a placeholder only used
 * by the system generated rollout to delete a service.
 */
export interface Schema$DeleteServiceStrategy {
}
/**
 * Represents a diagnostic message (error or warning)
 */
export interface Schema$Diagnostic {
    /**
     * The kind of diagnostic information provided.
     */
    kind: string;
    /**
     * File name and line number of the error or warning.
     */
    location: string;
    /**
     * Message describing the error or warning.
     */
    message: string;
}
/**
 * Request message for DisableService method.
 */
export interface Schema$DisableServiceRequest {
    /**
     * The identity of consumer resource which service disablement will be applied
     * to.  The Google Service Management implementation accepts the following
     * forms: - "project:<project_id>"  Note: this is made
     * compatible with google.api.servicecontrol.v1.Operation.consumer_id.
     */
    consumerId: string;
}
/**
 * `Documentation` provides the information for describing a service.  Example:
 * <pre><code>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: >       ...
 * </code></pre> 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:
 * <pre><code>[fully.qualified.proto.name][]</code></pre>
 * To override the display text used for the link, this can be used:
 * <pre><code>[display
 * text][fully.qualified.proto.name]</code></pre> Text can
 * be excluded from doc using the following notation:
 * <pre><code>(-- internal comment
 * --)</code></pre>  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: <pre><code>(== include path/to/file
 * ==)</code></pre> 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: <pre><code>(== resource_for v1.shelves.books
 * ==)</code></pre> The directive `suppress_warning` does
 * not directly affect documentation and is documented together with service
 * config validation.
 */
export interface Schema$Documentation {
    /**
     * The URL to the root of documentation.
     */
    documentationRootUrl: string;
    /**
     * Declares a single overview page. For example:
     * <pre><code>documentation:   summary: ...   overview:
     * (== include overview.md ==) </code></pre> This
     * is a shortcut for the following declaration (using pages style):
     * <pre><code>documentation:   summary: ...   pages:   - name:
     * Overview     content: (== include overview.md ==)
     * </code></pre> Note: you cannot specify both `overview` field
     * and `pages` field.
     */
    overview: string;
    /**
     * The top level pages for the documentation set.
     */
    pages: Schema$Page[];
    /**
     * A list of documentation rules that apply to individual API elements.
     * **NOTE:** All service configuration rules follow "last one wins"
     * order.
     */
    rules: Schema$DocumentationRule[];
    /**
     * A short summary of what the service does. Can only be provided by plain
     * text.
     */
    summary: string;
}
/**
 * A documentation rule provides information about individual API elements.
 */
export interface Schema$DocumentationRule {
    /**
     * Deprecation description of the selected element(s). It can be provided if
     * an element is marked as `deprecated`.
     */
    deprecationDescription: string;
    /**
     * Description of the selected API(s).
     */
    description: 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.
     */
    selector: string;
}
/**
 * Request message for EnableService method.
 */
export interface Schema$EnableServiceRequest {
    /**
     * The identity of consumer resource which service enablement will be applied
     * to.  The Google Service Management implementation accepts the following
     * forms: - "project:<project_id>"  Note: this is made
     * compatible with google.api.servicecontrol.v1.Operation.consumer_id.
     */
    consumerId: string;
}
/**
 * `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
 */
export interface Schema$Endpoint {
    /**
     * DEPRECATED: This field is no longer supported. Instead of using aliases,
     * please specify multiple google.api.Endpoint for each of the intended
     * aliases.  Additional names that this endpoint will be hosted on.
     */
    aliases: string[];
    /**
     * 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.
     */
    allowCors: boolean;
    /**
     * The list of features enabled on this endpoint.
     */
    features: string[];
    /**
     * The canonical name of this endpoint.
     */
    name: 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".
     */
    target: string;
}
/**
 * Enum type definition.
 */
export interface Schema$Enum {
    /**
     * Enum value definitions.
     */
    enumvalue: Schema$EnumValue[];
    /**
     * Enum type name.
     */
    name: string;
    /**
     * Protocol buffer options.
     */
    options: Schema$Option[];
    /**
     * The source context.
     */
    sourceContext: Schema$SourceContext;
    /**
     * The source syntax.
     */
    syntax: string;
}
/**
 * Enum value definition.
 */
export interface Schema$EnumValue {
    /**
     * Enum value name.
     */
    name: string;
    /**
     * Enum value number.
     */
    number: number;
    /**
     * Protocol buffer options.
     */
    options: Schema$Option[];
}
/**
 * Experimental service configuration. These configuration options can only be
 * used by whitelisted users.
 */
export interface Schema$Experimental {
    /**
     * Authorization configuration.
     */
    authorization: Schema$AuthorizationConfig;
}
/**
 * A single field of a message type.
 */
export interface Schema$Field {
    /**
     * The field cardinality.
     */
    cardinality: string;
    /**
     * The string value of the default value of this field. Proto2 syntax only.
     */
    defaultValue: string;
    /**
     * The field JSON name.
     */
    jsonName: string;
    /**
     * The field type.
     */
    kind: string;
    /**
     * The field name.
     */
    name: string;
    /**
     * The field number.
     */
    number: number;
    /**
     * 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.
     */
    oneofIndex: number;
    /**
     * The protocol buffer options.
     */
    options: Schema$Option[];
    /**
     * Whether to use alternative packed wire representation.
     */
    packed: boolean;
    /**
     * The field type URL, without the scheme, for message or enumeration types.
     * Example: `"type.googleapis.com/google.protobuf.Timestamp"`.
     */
    typeUrl: string;
}
/**
 * Request message for GenerateConfigReport method.
 */
export interface Schema$GenerateConfigReportRequest {
    /**
     * Service configuration for which we want to generate the report. For this
     * version of API, the supported types are
     * google.api.servicemanagement.v1.ConfigRef,
     * google.api.servicemanagement.v1.ConfigSource, and google.api.Service
     */
    newConfig: any;
    /**
     * Service configuration against which the comparison will be done. For this
     * version of API, the supported types are
     * google.api.servicemanagement.v1.ConfigRef,
     * google.api.servicemanagement.v1.ConfigSource, and google.api.Service
     */
    oldConfig: any;
}
/**
 * Response message for GenerateConfigReport method.
 */
export interface Schema$GenerateConfigReportResponse {
    /**
     * list of ChangeReport, each corresponding to comparison between two service
     * configurations.
     */
    changeReports: Schema$ChangeReport[];
    /**
     * Errors / Linter warnings associated with the service definition this report
     * belongs to.
     */
    diagnostics: Schema$Diagnostic[];
    /**
     * ID of the service configuration this report belongs to.
     */
    id: string;
    /**
     * Name of the service this report belongs to.
     */
    serviceName: string;
}
/**
 * Request message for `GetIamPolicy` method.
 */
export interface Schema$GetIamPolicyRequest {
}
/**
 * Defines the HTTP configuration for an API service. It contains a list of
 * HttpRule, each specifying the mapping of an RPC method to one or more HTTP
 * REST API methods.
 */
export interface Schema$Http {
    /**
     * When set to true, URL path parmeters will be fully URI-decoded except in
     * cases of single segment matches in reserved expansion, where
     * "%2F" will be left encoded.  The default behavior is to not
     * decode RFC 6570 reserved characters in multi segment matches.
     */
    fullyDecodeReservedExpansion: boolean;
    /**
     * A list of HTTP configuration rules that apply to individual API methods.
     * **NOTE:** All service configuration rules follow "last one wins"
     * order.
     */
    rules: Schema$HttpRule[];
}
/**
 * `HttpRule` defines the mapping of an RPC method to one or more HTTP REST API
 * methods. The mapping specifies how different portions of the RPC request
 * message are mapped to URL path, URL query parameters, and HTTP request body.
 * The mapping is typically specified as an `google.api.http` annotation on the
 * RPC method, 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:
 * <proto_package_name>.Messaging.GetMessage           get:
 * /v1/messages/{message_id}/{sub.subfield}  This definition enables an
 * automatic, bidrectional mapping of HTTP JSON to RPC. Example:  HTTP | RPC
 * -----|----- `GET /v1/messages/123456/foo`  | `GetMessage(message_id:
 * "123456" sub: SubMessage(subfield: "foo"))`  In general,
 * not only fields but also field paths can be referenced from a path pattern.
 * Fields mapped to the path pattern cannot be repeated and must have a
 * primitive (non-message) type.  Any fields in the request message which are
 * not bound by the path pattern automatically become (optional) HTTP query
 * parameters. Assume the following definition of the request message: 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&param=B`.  For HTTP method
 * kinds which allow a request body, the `body` field specifies the mapping.
 * Consider a REST update method on the message resource collection: 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 indicates there is no HTTP request 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. The syntax `**` matches zero or
 * more path segments, which must be the last part of the path except the
 * `Verb`. The syntax `LITERAL` matches literal text in the path.  The syntax
 * `Variable` matches part of the URL path as specified by its template. A
 * variable template must not contain other variables. If a variable matches a
 * single path segment, its template may be omitted, e.g. `{var}` is equivalent
 * to `{var=*}`.  If a variable contains exactly one path segment, such as
 * `"{var}"` or `"{var=*}"`, when such a variable is
 * expanded into a URL path, all characters except `[-_.~0-9a-zA-Z]` are
 * percent-encoded. Such variables show up in the Discovery Document as `{var}`.
 * If a variable contains one or more path segments, such as
 * `"{var=foo/*}"` or `"{var=**}"`, when such a variable is
 * expanded into a URL path, all characters except `[-_.~/0-9a-zA-Z]` are
 * percent-encoded. Such variables show up in the Discovery Document as
 * `{+var}`.  NOTE: While the single segment variable matches the semantics of
 * [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2 Simple String
 * Expansion, the multi segment variable **does not** match RFC 6570 Reserved
 * Expansion. The reason is that the Reserved Expansion does not expand special
 * characters like `?` and `#`, which would lead to invalid URLs.  NOTE: the
 * field paths in variables and in the `body` must not refer to repeated fields
 * or map fields.
 */
export interface Schema$HttpRule {
    /**
     * 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).
     */
    additionalBindings: Schema$HttpRule[];
    /**
     * 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.
     */
    body: string;
    /**
     * The custom pattern is used for specifying an HTTP method that is not
     * included in the `pattern` field, such as HEAD, or "*" to leave
     * the HTTP method unspecified for this rule. The wild-card rule is useful for
     * services that provide content to Web (HTML) clients.
     */
    custom: Schema$CustomHttpPattern;
    /**
     * Used for deleting a resource.
     */
    delete: string;
    /**
     * Used for listing and getting information about resources.
     */
    get: string;
    /**
     * 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.
     */
    mediaDownload: Schema$MediaDownload;
    /**
     * 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.
     */
    mediaUpload: Schema$MediaUpload;
    /**
     * Used for updating a resource.
     */
    patch: string;
    /**
     * Used for creating a resource.
     */
    post: string;
    /**
     * Used for updating a resource.
     */
    put: string;
    /**
     * Selects methods to which this rule applies.  Refer to selector for syntax
     * details.
     */
    selector: string;
}
/**
 * A description of a label.
 */
export interface Schema$LabelDescriptor {
    /**
     * A human-readable description for the label.
     */
    description: string;
    /**
     * The label key.
     */
    key: string;
    /**
     * The type of data that can be assigned to the label.
     */
    valueType: string;
}
/**
 * The response message for Operations.ListOperations.
 */
export interface Schema$ListOperationsResponse {
    /**
     * The standard List next-page token.
     */
    nextPageToken: string;
    /**
     * A list of operations that matches the specified filter in the request.
     */
    operations: Schema$Operation[];
}
/**
 * Response message for ListServiceConfigs method.
 */
export interface Schema$ListServiceConfigsResponse {
    /**
     * The token of the next page of results.
     */
    nextPageToken: string;
    /**
     * The list of service configuration resources.
     */
    serviceConfigs: Schema$Service[];
}
/**
 * Response message for ListServiceRollouts method.
 */
export interface Schema$ListServiceRolloutsResponse {
    /**
     * The token of the next page of results.
     */
    nextPageToken: string;
    /**
     * The list of rollout resources.
     */
    rollouts: Schema$Rollout[];
}
/**
 * Response message for `ListServices` method.
 */
export interface Schema$ListServicesResponse {
    /**
     * Token that can be passed to `ListServices` to resume a paginated query.
     */
    nextPageToken: string;
    /**
     * The returned services will only have the name field set.
     */
    services: Schema$ManagedService[];
}
/**
 * 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
 */
export interface Schema$LogDescriptor {
    /**
     * A human-readable description of this log. This information appears in the
     * documentation and can contain details.
     */
    description: string;
    /**
     * The human-readable name for this log. This information appears on the user
     * interface and should be concise.
     */
    displayName: string;
    /**
     * The set of labels that are available to describe a specific log entry.
     * Runtime requests that contain labels not specified here are considered
     * invalid.
     */
    labels: Schema$LabelDescriptor[];
    /**
     * 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 [/_-.].
     */
    name: string;
}
/**
 * Logging configuration of the service.  The following example shows how to
 * config