googleapis
Version:
Google APIs Client Library for Node.js
1,207 lines • 98.4 kB
TypeScript
/**
* 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';
/**
* Service Usage API
*
* Enables services that service consumers want to use on Google Cloud Platform,
* lists the available or enabled services, or disables services that service
* consumers no longer use.
*
* @example
* const google = require('googleapis');
* const serviceusage = google.serviceusage('v1beta1');
*
* @namespace serviceusage
* @type {Function}
* @version v1beta1
* @variation v1beta1
* @param {object=} options Options for Serviceusage
*/
export declare class Serviceusage {
_options: GlobalOptions;
google: GoogleApis;
root: this;
operations: Resource$Operations;
services: Resource$Services;
constructor(options: GlobalOptions, google: GoogleApis);
getRoot(): this;
}
/**
* 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;
}
/**
* `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;
}
/**
* Authorization rule for API services. It specifies the permission(s) required
* for an API element for the overall API request to succeed. It is typically
* used to mark request message fields that contain the name of the resource and
* indicates the permissions that will be checked on that resource. For
* example: package google.storage.v1; message CopyObjectRequest {
* string source = 1 [ (google.api.authz).permissions =
* "storage.objects.get"]; string destination = 2 [
* (google.api.authz).permissions =
* "storage.objects.create,storage.objects.update"]; }
*/
export interface Schema$AuthorizationRule {
/**
* The required permissions. The acceptable values vary depend on the
* authorization system used. For Google APIs, it should be a comma-separated
* Google IAM permission values. When multiple permissions are listed, the
* semantics is not defined by the system. Additional documentation must be
* provided manually.
*/
permissions: string;
/**
* Selects the API elements to which this rule applies. Refer to selector for
* syntax details.
*/
selector: 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;
}
/**
* Request message for the `BatchEnableServices` method.
*/
export interface Schema$BatchEnableServicesRequest {
/**
* The identifiers of the services to enable on the project. A valid
* identifier would be: serviceusage.googleapis.com Enabling services
* requires that each service is public or is shared with the user enabling
* the service. Two or more services must be specified. To enable a single
* service, use the `EnableService` method instead. A single request can
* enable a maximum of 20 services at a time. If more than 20 services are
* specified, the request will fail, and no state changes will occur.
*/
serviceIds: 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;
}
/**
* `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;
}
/**
* Request message for the `DisableService` method.
*/
export interface Schema$DisableServiceRequest {
}
/**
* `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: &#40;== include google/foo/overview.md ==&#41; - name:
* Tutorial content: &#40;== include google/foo/tutorial.md ==&#41;
* subpages; - name: Java content: &#40;== include
* google/foo/tutorial_java.md ==&#41; 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>&#91;fully.qualified.proto.name]&#91;]</code></pre>
* To override the display text used for the link, this can be used:
* <pre><code>&#91;display
* text]&#91;fully.qualified.proto.name]</code></pre> Text can
* be excluded from doc using the following notation:
* <pre><code>&#40;-- internal comment
* --&#41;</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>&#40;== include path/to/file
* ==&#41;</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>&#40;== resource_for v1.shelves.books
* ==&#41;</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:
* &#40;== include overview.md ==&#41; </code></pre> This
* is a shortcut for the following declaration (using pages style):
* <pre><code>documentation: summary: ... pages: - name:
* Overview content: &#40;== include overview.md ==&#41;
* </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 the `EnableService` method.
*/
export interface Schema$EnableServiceRequest {
}
/**
* `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;
}
/**
* `Service` is the root object of Google service configuration schema. It
* 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
*/
export interface Schema$GoogleApiService {
/**
* 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.
*/
apis: Schema$Api[];
/**
* Auth configuration.
*/
authentication: Schema$Authentication;
/**
* API backend configuration.
*/
backend: Schema$Backend;
/**
* Billing configuration.
*/
billing: Schema$Billing;
/**
* The semantic version of the service configuration. The config version
* affects the interpretation of the service configuration. For example,
* certain features are enabled by default for certain config versions. The
* latest config version is `3`.
*/
configVersion: number;
/**
* Context configuration.
*/
context: Schema$Context;
/**
* Configuration for the service control plane.
*/
control: Schema$Control;
/**
* Custom error configuration.
*/
customError: Schema$CustomError;
/**
* Additional API documentation.
*/
documentation: Schema$Documentation;
/**
* 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.
*/
endpoints: Schema$Endpoint[];
/**
* 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
*/
enums: Schema$Enum[];
/**
* Experimental configuration.
*/
experimental: Schema$Experimental;
/**
* HTTP configuration.
*/
http: Schema$Http;
/**
* 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;
/**
* Logging configuration.
*/
logging: Schema$Logging;
/**
* Defines the logs used by this service.
*/
logs: Schema$LogDescriptor[];
/**
* Defines the metrics used by this service.
*/
metrics: Schema$MetricDescriptor[];
/**
* Defines the monitored resources used by this service. This is required by
* the Service.monitoring and Service.logging configurations.
*/
monitoredResources: Schema$MonitoredResourceDescriptor[];
/**
* Monitoring configuration.
*/
monitoring: Schema$Monitoring;
/**
* The DNS address at which this service is available, e.g.
* `calendar.googleapis.com`.
*/
name: string;
/**
* The Google project that owns this service.
*/
producerProjectId: string;
/**
* Quota configuration.
*/
quota: Schema$Quota;
/**
* Output only. The source information for this configuration if available.
*/
sourceInfo: Schema$SourceInfo;
/**
* System parameter configuration.
*/
systemParameters: Schema$SystemParameters;
/**
* A list of all proto message types included in this API service. It serves
* similar purpose as [google.api.Service.types], except that these types are
* not needed by user-defined APIs. Therefore, they will not show up in the
* generated discovery doc. This field should only be used to define system
* APIs in ESF.
*/
systemTypes: Schema$Type[];
/**
* The product title for this service.
*/
title: string;
/**
* 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
*/
types: Schema$Type[];
/**
* Configuration controlling usage of this service.
*/
usage: Schema$Usage;
}
/**
* 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[];
/**
* Specifies the permission(s) required for an API element for the overall API
* request to succeed. It is typically used to mark request message fields
* that contain the name of the resource and indicates the permissions that
* will be checked on that resource.
*/
authorizations: Schema$AuthorizationRule[];
/**
* 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;
/**
* DO NOT USE. This is an experimental field. 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.
*/
restCollection: string;
/**
* DO NOT USE. This is an experimental field. 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 compatibility with apiary, it is specified as insert.
*/
restMethodName: 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 the `ListServices` method.
*/
export interface Schema$ListServicesResponse {
/**
* Token that can be passed to `ListServices` to resume a paginated query.
*/
nextPageToken: string;
/**
* The available services for the requested project.
*/
services: Schema$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
*/
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
* 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
*/
export interface Schema$Logging {
/**
* 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.
*/
consumerDestinations: Schema$LoggingDestination[];
/**
* 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.
*/
producerDestinations: Schema$LoggingDestination[];
}
/**
* Configuration of a specific logging destination (the producer project or the
* consumer project).
*/
export interface Schema$LoggingDestination {
/**
* 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
* "/".
*/
logs: string[];
/**
* The monitored resource type. T