google-gax

  • Version 2.27.0
  • Published
  • 10.9 MB
  • 13 dependencies
  • Apache-2.0 license

Install

npm i google-gax
yarn add google-gax
pnpm add google-gax

Overview

Google API Extensions

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable createByteLengthFunction

const createByteLengthFunction: (message: {
encode: (obj: {}) => { finish: () => {}[] };
}) => (obj: {}) => number;

    variable version

    const version: any;

      Functions

      function constructSettings

      constructSettings: (
      serviceName: string,
      clientConfig: ClientConfig,
      configOverrides: ClientConfig,
      retryNames: {},
      otherArgs?: {}
      ) => any;
      • Constructs a dictionary mapping method names to CallSettings.

        The clientConfig parameter is parsed from a client configuration JSON file of the form:

        { "interfaces": { "google.fake.v1.ServiceName": { "retry_codes": { "idempotent": ["UNAVAILABLE", "DEADLINE_EXCEEDED"], "non_idempotent": [] }, "retry_params": { "default": { "initial_retry_delay_millis": 100, "retry_delay_multiplier": 1.2, "max_retry_delay_millis": 1000, "initial_rpc_timeout_millis": 2000, "rpc_timeout_multiplier": 1.5, "max_rpc_timeout_millis": 30000, "total_timeout_millis": 45000 } }, "methods": { "CreateFoo": { "retry_codes_name": "idempotent", "retry_params_name": "default" }, "Publish": { "retry_codes_name": "non_idempotent", "retry_params_name": "default", "bundling": { "element_count_threshold": 40, "element_count_limit": 200, "request_byte_threshold": 90000, "request_byte_limit": 100000, "delay_threshold_millis": 100 } } } } } }

        Parameter serviceName

        The fully-qualified name of this service, used as a key into the client config file (in the example above, this value should be 'google.fake.v1.ServiceName').

        Parameter clientConfig

        A dictionary parsed from the standard API client config file.

        Parameter configOverrides

        A dictionary in the same structure of client_config to override the settings.

        Parameter retryNames

        A dictionary mapping the strings referring to response status codes to objects representing those codes.

        Parameter otherArgs

        the non-request arguments to be passed to the API calls. {Object} A mapping from method name to CallSettings, or null if the service is not found in the config.

      function createApiCall

      createApiCall: (
      func: Promise<GRPCCall> | GRPCCall,
      settings: CallSettings,
      descriptor?: Descriptor
      ) => GaxCall;
      • Converts an rpc call into an API call governed by the settings.

        In typical usage, func will be a promise to a callable used to make an rpc request. This will mostly likely be a bound method from a request stub used to make an rpc call. It is not a direct function but a Promise instance, because of its asynchronism (typically, obtaining the auth information).

        The result is a function which manages the API call with the given settings and the options on the invocation.

        Parameter func

        is either a promise to be used to make a bare RPC call, or just a bare RPC call.

        Parameter settings

        provides the settings for this call

        Parameter descriptor

        optionally specify the descriptor for the method call. {GaxCall} func - a bound method on a request stub used to make an rpc call.

      function createBackoffSettings

      createBackoffSettings: (
      initialRetryDelayMillis: number,
      retryDelayMultiplier: number,
      maxRetryDelayMillis: number,
      initialRpcTimeoutMillis: number | null,
      rpcTimeoutMultiplier: number | null,
      maxRpcTimeoutMillis: number | null,
      totalTimeoutMillis: number | null
      ) => BackoffSettings;
      • Parameters to the exponential backoff algorithm for retrying.

        Parameter initialRetryDelayMillis

        the initial delay time, in milliseconds, between the completion of the first failed request and the initiation of the first retrying request.

        Parameter retryDelayMultiplier

        the multiplier by which to increase the delay time between the completion of failed requests, and the initiation of the subsequent retrying request.

        Parameter maxRetryDelayMillis

        the maximum delay time, in milliseconds, between requests. When this value is reached, ``retryDelayMultiplier`` will no longer be used to increase delay time.

        Parameter initialRpcTimeoutMillis

        the initial timeout parameter to the request.

        Parameter rpcTimeoutMultiplier

        the multiplier by which to increase the timeout parameter between failed requests.

        Parameter maxRpcTimeoutMillis

        the maximum timeout parameter, in milliseconds, for a request. When this value is reached, ``rpcTimeoutMultiplier`` will no longer be used to increase the timeout.

        Parameter totalTimeoutMillis

        the total time, in milliseconds, starting from when the initial request is sent, after which an error will be returned, regardless of the retrying attempts made meanwhile. {BackoffSettings} a new settings.

      function createBundleOptions

      createBundleOptions: (options: BundlingConfig) => BundleOptions;
      • Creates a new BundleOptions.

        Parameter options

        An object to hold optional parameters. See properties for the content of options. {BundleOptions} - A new options.

      function createDefaultBackoffSettings

      createDefaultBackoffSettings: () => BackoffSettings;

        function createMaxRetriesBackoffSettings

        createMaxRetriesBackoffSettings: (
        initialRetryDelayMillis: number,
        retryDelayMultiplier: number,
        maxRetryDelayMillis: number,
        initialRpcTimeoutMillis: number,
        rpcTimeoutMultiplier: number,
        maxRpcTimeoutMillis: number,
        maxRetries: number
        ) => BackoffSettings;
        • Parameters to the exponential backoff algorithm for retrying. This function is unsupported, and intended for internal use only.

          Parameter initialRetryDelayMillis

          the initial delay time, in milliseconds, between the completion of the first failed request and the initiation of the first retrying request.

          Parameter retryDelayMultiplier

          the multiplier by which to increase the delay time between the completion of failed requests, and the initiation of the subsequent retrying request.

          Parameter maxRetryDelayMillis

          the maximum delay time, in milliseconds, between requests. When this value is reached, ``retryDelayMultiplier`` will no longer be used to increase delay time.

          Parameter initialRpcTimeoutMillis

          the initial timeout parameter to the request.

          Parameter rpcTimeoutMultiplier

          the multiplier by which to increase the timeout parameter between failed requests.

          Parameter maxRpcTimeoutMillis

          the maximum timeout parameter, in milliseconds, for a request. When this value is reached, ``rpcTimeoutMultiplier`` will no longer be used to increase the timeout.

          Parameter maxRetries

          the maximum number of retrying attempts that will be made. If reached, an error will be returned. {BackoffSettings} a new settings.

        function createRetryOptions

        createRetryOptions: (
        retryCodes: number[],
        backoffSettings: BackoffSettings
        ) => RetryOptions;
        • Per-call configurable settings for retrying upon transient failure.

          Parameter retryCodes

          a list of Google API canonical error codes upon which a retry should be attempted.

          Parameter backoffSettings

          configures the retry exponential backoff algorithm. {RetryOptions} A new RetryOptions object.

        function lro

        lro: typeof lro;

          function operation

          operation: (
          op: LROOperation,
          longrunningDescriptor: LongRunningDescriptor,
          backoffSettings: BackoffSettings,
          callOptions?: CallOptions
          ) => Operation;
          • Method used to create Operation objects.

            Parameter op

            The operation to be wrapped.

            Parameter longrunningDescriptor

            This defines the operations service client and unpacking mechanisms for the operation.

            Parameter backoffSettings

            The backoff settings used in in polling the operation.

            Parameter callOptions

            CallOptions used in making get operation requests.

          function warn

          warn: (code: string, message: string, warnType?: string) => void;
          • Copyright 2020 Google LLC

            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.

          Classes

          class BundleDescriptor

          class BundleDescriptor implements Descriptor {}
          • A descriptor for calls that can be bundled into one call.

          constructor

          constructor(
          bundledField: string,
          requestDiscriminatorFields: string[],
          subresponseField: string,
          byteLengthFunction: Function
          );
          • Describes the structure of bundled call.

            requestDiscriminatorFields may include '.' as a separator, which is used to indicate object traversal. This allows fields in nested objects to be used to determine what request to bundle.

            {String} bundledField {String} requestDiscriminatorFields {String} subresponseField {Function} byteLengthFunction

            Parameter bundledField

            the repeated field in the request message that will have its elements aggregated by bundling.

            Parameter requestDiscriminatorFields

            a list of fields in the target request message class that are used to detemrine which request messages should be bundled together.

            Parameter subresponseField

            an optional field, when present it indicates the field in the response message that should be used to demultiplex the response into multiple response messages.

            Parameter byteLengthFunction

            a function to obtain the byte length to be consumed for the bundled field messages. Because Node.JS protobuf.js/gRPC uses builtin Objects for the user-visible data and internally they are encoded/decoded in protobuf manner, this function is actually necessary to calculate the byte length.

          property bundledField

          bundledField: string;

            property byteLengthFunction

            byteLengthFunction: Function;

              property requestDiscriminatorFields

              requestDiscriminatorFields: string[];

                property subresponseField

                subresponseField: string;

                  method getApiCaller

                  getApiCaller: (settings: CallSettings) => NormalApiCaller | BundleApiCaller;

                    class CallSettings

                    class CallSettings {}

                      constructor

                      constructor(settings?: CallOptions);
                      • Parameter settings

                        An object containing parameters of this settings.

                        Parameter

                        {number} settings.timeout - The client-side timeout for API calls. This parameter is ignored for retrying calls.

                        Parameter

                        {RetryOptions} settings.retry - The configuration for retrying upon transient error. If set to null, this call will not retry.

                        Parameter

                        {boolean} settings.autoPaginate - If there is no pageDescriptor, this attrbute has no meaning. Otherwise, determines whether a page streamed response should make the page structure transparent to the user by flattening the repeated field in the returned generator.

                        Parameter

                        {number} settings.pageToken - If there is no pageDescriptor, this attribute has no meaning. Otherwise, determines the page token used in the page streaming request.

                        Parameter

                        {Object} settings.otherArgs - Additional arguments to be passed to the API calls.

                      property apiName

                      apiName?: string;

                        property autoPaginate

                        autoPaginate?: boolean;

                          property bundleOptions

                          bundleOptions?: BundleOptions;

                            property isBundling

                            isBundling: boolean;

                              property longrunning

                              longrunning?: BackoffSettings;

                                property maxResults

                                maxResults?: number;

                                  property otherArgs

                                  otherArgs: { [index: string]: any };

                                    property pageSize

                                    pageSize?: number;

                                      property pageToken

                                      pageToken?: string;

                                        property retry

                                        retry?: RetryOptions;

                                          property retryRequestOptions

                                          retryRequestOptions?: RetryRequestOptions;

                                            property timeout

                                            timeout: number;

                                              method merge

                                              merge: (options?: CallOptions | null) => CallSettings;
                                              • Returns a new CallSettings merged from this and a CallOptions object.

                                                Parameter options

                                                an instance whose values override those in this object. If null, ``merge`` returns a copy of this object {CallSettings} The merged CallSettings instance.

                                              class ClientStub

                                              class ClientStub extends grpc.Client {}

                                                class GoogleError

                                                class GoogleError extends Error {}

                                                  property code

                                                  code?: Status;

                                                    property domain

                                                    domain?: string;

                                                      property errorInfoMetadata

                                                      errorInfoMetadata?: { string: string };

                                                        property metadata

                                                        metadata?: Metadata;

                                                          property note

                                                          note?: string;

                                                            property reason

                                                            reason?: string;

                                                              property statusDetails

                                                              statusDetails?: string | any[];

                                                                method parseGRPCStatusDetails

                                                                static parseGRPCStatusDetails: (err: GoogleError) => GoogleError;

                                                                  method parseHttpError

                                                                  static parseHttpError: (json: any) => GoogleError;

                                                                    class GoogleProtoFilesRoot

                                                                    class GoogleProtoFilesRoot extends protobuf.Root {}

                                                                      constructor

                                                                      constructor(...args: {}[]);

                                                                        method resolvePath

                                                                        resolvePath: (originPath: string, includePath: string) => string;

                                                                          class GrpcClient

                                                                          class GrpcClient {}

                                                                            constructor

                                                                            constructor(options?: GrpcClientOptions);
                                                                            • A class which keeps the context of gRPC and auth for the gRPC.

                                                                              Parameter options

                                                                              The optional parameters. It will be directly passed to google-auth-library library, so parameters like keyFile or credentials will be valid.

                                                                              Parameter

                                                                              {Object=} options.auth - An instance of google-auth-library. When specified, this auth instance will be used instead of creating a new one.

                                                                              Parameter

                                                                              {Object=} options.grpc - When specified, this will be used for the 'grpc' module in this context. By default, it will load the grpc module in the standard way.

                                                                            property auth

                                                                            auth: any;

                                                                              property fallback

                                                                              fallback: boolean | 'rest' | 'proto';

                                                                                property grpc

                                                                                grpc: any;

                                                                                  property grpcVersion

                                                                                  grpcVersion: string;

                                                                                    method clearProtoCache

                                                                                    static clearProtoCache: () => void;
                                                                                    • In rare cases users might need to deallocate all memory consumed by loaded protos. This method will delete the proto cache content.

                                                                                    method constructSettings

                                                                                    constructSettings: (
                                                                                    serviceName: string,
                                                                                    clientConfig: gax.ClientConfig,
                                                                                    configOverrides: gax.ClientConfig,
                                                                                    headers: any
                                                                                    ) => any;
                                                                                    • A wrapper of constructSettings function under the gRPC context.

                                                                                      Most of parameters are common among constructSettings, please take a look.

                                                                                      Parameter serviceName

                                                                                      The fullly-qualified name of the service.

                                                                                      Parameter clientConfig

                                                                                      A dictionary of the client config.

                                                                                      Parameter configOverrides

                                                                                      A dictionary of overriding configs.

                                                                                      Parameter headers

                                                                                      A dictionary of additional HTTP header name to its value. {Object} A mapping of method names to CallSettings.

                                                                                    method createByteLengthFunction

                                                                                    static createByteLengthFunction: (message: {
                                                                                    encode: (obj: {}) => { finish: () => Array<{}> };
                                                                                    }) => (obj: {}) => number;
                                                                                    • Creates a 'bytelength' function for a given proto message class.

                                                                                      See BundleDescriptor about the meaning of the return value.

                                                                                      Parameter message

                                                                                      a constructor function that is generated by protobuf.js. Assumes 'encoder' field in the message. {function(Object):number} - a function to compute the byte length for an object.

                                                                                    method createStub

                                                                                    createStub: (
                                                                                    CreateStub: typeof ClientStub,
                                                                                    options: ClientStubOptions,
                                                                                    customServicePath?: boolean
                                                                                    ) => Promise<ClientStub>;
                                                                                    • Creates a gRPC stub with current gRPC and auth.

                                                                                      Parameter CreateStub

                                                                                      The constructor function of the stub.

                                                                                      Parameter options

                                                                                      The optional arguments to customize gRPC connection. This options will be passed to the constructor of gRPC client too.

                                                                                      Parameter

                                                                                      {string} options.servicePath - The name of the server of the service.

                                                                                      Parameter

                                                                                      {number} options.port - The port of the service.

                                                                                      Parameter

                                                                                      {grpcTypes.ClientCredentials=} options.sslCreds - The credentials to be used to set up gRPC connection.

                                                                                      Parameter defaultServicePath

                                                                                      The default service path. {Promise} A promise which resolves to a gRPC stub instance.

                                                                                    method loadFromProto

                                                                                    loadFromProto: (
                                                                                    filename: string | string[],
                                                                                    options: any,
                                                                                    ignoreCache?: boolean
                                                                                    ) => any;
                                                                                    • Loads the gRPC service from the proto file(s) at the given path and with the given options. Caches the loaded protos so the subsequent loads don't do any disk reads.

                                                                                      Parameter filename

                                                                                      The path to the proto file(s).

                                                                                      Parameter options

                                                                                      Options for loading the proto file.

                                                                                      Parameter ignoreCache

                                                                                      Defaults to false. Set it to true if the caching logic incorrectly decides that the options object is the same, or if you want to re-read the protos from disk for any other reason.

                                                                                    method loadProto

                                                                                    loadProto: (
                                                                                    protoPath: string,
                                                                                    filename?: string | string[],
                                                                                    ignoreCache?: boolean
                                                                                    ) => any;
                                                                                    • Load gRPC proto service from a filename looking in googleapis common protos when necessary. Caches the loaded protos so the subsequent loads don't do any disk reads.

                                                                                      Parameter protoPath

                                                                                      The directory to search for the protofile.

                                                                                      Parameter filename

                                                                                      The filename(s) of the proto(s) to be loaded. If omitted, protoPath will be treated as a file path to load.

                                                                                      Parameter ignoreCache

                                                                                      Defaults to false. Set it to true if the caching logic incorrectly decides that the options object is the same, or if you want to re-read the protos from disk for any other reason. {Object<string, *>} The gRPC loaded result (the toplevel namespace object).

                                                                                    method loadProtoJSON

                                                                                    loadProtoJSON: (json: any, ignoreCache?: boolean) => any;

                                                                                      method metadataBuilder

                                                                                      metadataBuilder: (
                                                                                      headers: any
                                                                                      ) => (
                                                                                      abTests?: {} | undefined,
                                                                                      moreHeaders?: OutgoingHttpHeaders | undefined
                                                                                      ) => any;

                                                                                        class IamClient

                                                                                        class IamClient {}
                                                                                        • Google Cloud IAM Client. This is manually written for providing methods [setIamPolicy, getIamPolicy, testIamPerssion] to the generated client.

                                                                                        constructor

                                                                                        constructor(gaxGrpc: GrpcClient | FallbackGrpcClient, options: ClientOptions);

                                                                                          property apiEndpoint

                                                                                          static readonly apiEndpoint: string;
                                                                                          • The DNS address for this API service - same as servicePath(), exists for compatibility reasons.

                                                                                          property auth

                                                                                          auth?: any;

                                                                                            property descriptors

                                                                                            descriptors: Descriptors;

                                                                                              property gaxGrpc

                                                                                              gaxGrpc: GrpcClient | FallbackGrpcClient;

                                                                                                property iamPolicyStub

                                                                                                iamPolicyStub?: Promise<{ [name: string]: Function }>;

                                                                                                  property innerApiCalls

                                                                                                  innerApiCalls: { [name: string]: Function };

                                                                                                    property port

                                                                                                    static readonly port: number;
                                                                                                    • The port for this API service.

                                                                                                    property scopes

                                                                                                    static readonly scopes: string[];
                                                                                                    • The scopes needed to make gRPC calls for every method defined in this service.

                                                                                                    property servicePath

                                                                                                    static readonly servicePath: string;
                                                                                                    • The DNS address for this API service.

                                                                                                    method close

                                                                                                    close: () => Promise<void>;
                                                                                                    • Terminate the GRPC channel and close the client.

                                                                                                      The client will no longer be usable and all future behavior is undefined.

                                                                                                    method getIamPolicy

                                                                                                    getIamPolicy: {
                                                                                                    (
                                                                                                    request: protos.google.iam.v1.GetIamPolicyRequest,
                                                                                                    options?: gax.CallOptions
                                                                                                    ): Promise<protos.google.iam.v1.Policy>;
                                                                                                    (
                                                                                                    request: protos.google.iam.v1.GetIamPolicyRequest,
                                                                                                    options: gax.CallOptions,
                                                                                                    callback: Callback<
                                                                                                    protos.google.iam.v1.Policy,
                                                                                                    protos.google.iam.v1.GetIamPolicyRequest,
                                                                                                    {}
                                                                                                    >
                                                                                                    ): void;
                                                                                                    (
                                                                                                    request: protos.google.iam.v1.GetIamPolicyRequest,
                                                                                                    callback: Callback<
                                                                                                    protos.google.iam.v1.Policy,
                                                                                                    protos.google.iam.v1.GetIamPolicyRequest,
                                                                                                    {}
                                                                                                    >
                                                                                                    ): void;
                                                                                                    (request: protos.google.iam.v1.GetIamPolicyRequest): void;
                                                                                                    (
                                                                                                    request: protos.google.iam.v1.GetIamPolicyRequest,
                                                                                                    options?:
                                                                                                    | gax.CallOptions
                                                                                                    | Callback<
                                                                                                    protos.google.iam.v1.Policy,
                                                                                                    protos.google.iam.v1.GetIamPolicyRequest,
                                                                                                    {}
                                                                                                    >,
                                                                                                    callback?: Callback<
                                                                                                    protos.google.iam.v1.Policy,
                                                                                                    protos.google.iam.v1.GetIamPolicyRequest,
                                                                                                    {}
                                                                                                    >
                                                                                                    ): Promise<protos.google.iam.v1.Policy>;
                                                                                                    };

                                                                                                      method getProjectId

                                                                                                      getProjectId: { (): Promise<string>; (callback: any): void };
                                                                                                      • Get the project ID used by this class.

                                                                                                        Parameter callback

                                                                                                        the callback to be called with the current project Id.

                                                                                                      method initialize

                                                                                                      initialize: () => Promise<{ [name: string]: Function }>;
                                                                                                      • Initialize the client. Performs asynchronous operations (such as authentication) and prepares the client. This function will be called automatically when any class method is called for the first time, but if you need to initialize it before calling an actual method, feel free to call initialize() directly.

                                                                                                        You can await on this method if you want to make sure the client is initialized.

                                                                                                        Returns

                                                                                                        {Promise} A promise that resolves to an authenticated service stub.

                                                                                                      method setIamPolicy

                                                                                                      setIamPolicy: {
                                                                                                      (
                                                                                                      request: protos.google.iam.v1.SetIamPolicyRequest,
                                                                                                      options?: gax.CallOptions
                                                                                                      ): Promise<protos.google.iam.v1.Policy>;
                                                                                                      (
                                                                                                      request: protos.google.iam.v1.SetIamPolicyRequest,
                                                                                                      options: gax.CallOptions,
                                                                                                      callback: Callback<
                                                                                                      protos.google.iam.v1.Policy,
                                                                                                      protos.google.iam.v1.SetIamPolicyRequest,
                                                                                                      {}
                                                                                                      >
                                                                                                      ): void;
                                                                                                      (
                                                                                                      request: protos.google.iam.v1.SetIamPolicyRequest,
                                                                                                      callback: Callback<
                                                                                                      protos.google.iam.v1.Policy,
                                                                                                      protos.google.iam.v1.SetIamPolicyRequest,
                                                                                                      {}
                                                                                                      >
                                                                                                      ): void;
                                                                                                      (request: protos.google.iam.v1.SetIamPolicyRequest): void;
                                                                                                      (
                                                                                                      request: protos.google.iam.v1.SetIamPolicyRequest,
                                                                                                      options?:
                                                                                                      | gax.CallOptions
                                                                                                      | Callback<
                                                                                                      protos.google.iam.v1.Policy,
                                                                                                      protos.google.iam.v1.SetIamPolicyRequest,
                                                                                                      {}
                                                                                                      >,
                                                                                                      callback?: Callback<
                                                                                                      protos.google.iam.v1.Policy,
                                                                                                      protos.google.iam.v1.SetIamPolicyRequest,
                                                                                                      {}
                                                                                                      >
                                                                                                      ): Promise<protos.google.iam.v1.Policy>;
                                                                                                      };

                                                                                                        method testIamPermissions

                                                                                                        testIamPermissions: {
                                                                                                        (
                                                                                                        request: protos.google.iam.v1.TestIamPermissionsRequest,
                                                                                                        options?: gax.CallOptions
                                                                                                        ): Promise<protos.google.iam.v1.TestIamPermissionsResponse>;
                                                                                                        (
                                                                                                        request: protos.google.iam.v1.TestIamPermissionsRequest,
                                                                                                        callback: Callback<
                                                                                                        protos.google.iam.v1.TestIamPermissionsResponse,
                                                                                                        protos.google.iam.v1.TestIamPermissionsRequest,
                                                                                                        {}
                                                                                                        >
                                                                                                        ): void;
                                                                                                        (
                                                                                                        request: protos.google.iam.v1.TestIamPermissionsRequest,
                                                                                                        options: gax.CallOptions,
                                                                                                        callback: Callback<
                                                                                                        protos.google.iam.v1.TestIamPermissionsResponse,
                                                                                                        protos.google.iam.v1.TestIamPermissionsRequest,
                                                                                                        {}
                                                                                                        >
                                                                                                        ): void;
                                                                                                        (request: protos.google.iam.v1.TestIamPermissionsRequest): void;
                                                                                                        (
                                                                                                        request: protos.google.iam.v1.TestIamPermissionsRequest,
                                                                                                        options?:
                                                                                                        | gax.CallOptions
                                                                                                        | Callback<
                                                                                                        protos.google.iam.v1.TestIamPermissionsResponse,
                                                                                                        protos.google.iam.v1.TestIamPermissionsRequest,
                                                                                                        {}
                                                                                                        >,
                                                                                                        callback?: Callback<
                                                                                                        protos.google.iam.v1.TestIamPermissionsResponse,
                                                                                                        protos.google.iam.v1.TestIamPermissionsRequest,
                                                                                                        {}
                                                                                                        >
                                                                                                        ): Promise<protos.google.iam.v1.TestIamPermissionsResponse>;
                                                                                                        };

                                                                                                          class LocationsClient

                                                                                                          class LocationsClient {}
                                                                                                          • Google Cloud Locations Client. This is manually written for providing methods [listLocations, getLocations] to the generated client.

                                                                                                          constructor

                                                                                                          constructor(gaxGrpc: GrpcClient | FallbackGrpcClient, opts: ClientOptions);
                                                                                                          • Construct an instance of LocationsClient.

                                                                                                            Parameter options

                                                                                                            The configuration object. The options accepted by the constructor are described in detail in [this document](https://github.com/googleapis/gax-nodejs/blob/main/client-libraries.md#creating-the-client-instance). The common options are:

                                                                                                            Parameter

                                                                                                            {object} [options.credentials] - Credentials object.

                                                                                                            Parameter

                                                                                                            {string} [options.credentials.client_email]

                                                                                                            Parameter

                                                                                                            {string} [options.credentials.private_key]

                                                                                                            Parameter

                                                                                                            {string} [options.email] - Account email address. Required when using a .pem or .p12 keyFilename.

                                                                                                            Parameter

                                                                                                            {string} [options.keyFilename] - Full path to the a .json, .pem, or .p12 key downloaded from the Google Developers Console. If you provide a path to a JSON file, the projectId option below is not necessary. NOTE: .pem and .p12 require you to specify options.email as well.

                                                                                                            Parameter

                                                                                                            {number} [options.port] - The port on which to connect to the remote host.

                                                                                                            Parameter

                                                                                                            {string} [options.projectId] - The project ID from the Google Developer's Console, e.g. 'grape-spaceship-123'. We will also check the environment variable GCLOUD_PROJECT for your project ID. If your app is running in an environment which supports , your project ID will be detected automatically.

                                                                                                            Parameter

                                                                                                            {string} [options.apiEndpoint] - The domain name of the API remote host.

                                                                                                            Parameter

                                                                                                            {gax.ClientConfig} [options.clientConfig] - Client configuration override. Follows the structure of gapicConfig.

                                                                                                            Parameter

                                                                                                            {boolean} [options.fallback] - Use HTTP fallback mode. In fallback mode, a special browser-compatible transport implementation is used instead of gRPC transport. In browser context (if the window object is defined) the fallback mode is enabled automatically; set options.fallback to false if you need to override this behavior.

                                                                                                          property apiEndpoint

                                                                                                          static readonly apiEndpoint: string;
                                                                                                          • The DNS address for this API service - same as servicePath(), exists for compatibility reasons.

                                                                                                            Returns

                                                                                                            {string} The DNS address for this service.

                                                                                                          property auth

                                                                                                          auth: any;

                                                                                                            property descriptors

                                                                                                            descriptors: Descriptors;

                                                                                                              property gaxGrpc

                                                                                                              gaxGrpc: GrpcClient | FallbackGrpcClient;

                                                                                                                property innerApiCalls

                                                                                                                innerApiCalls: { [name: string]: Function };

                                                                                                                  property locationsStub

                                                                                                                  locationsStub?: Promise<{ [name: string]: Function }>;

                                                                                                                    property PageDescriptor

                                                                                                                    PageDescriptor: any;

                                                                                                                      property port

                                                                                                                      static readonly port: number;
                                                                                                                      • The port for this API service.

                                                                                                                        Returns

                                                                                                                        {number} The default port for this service.

                                                                                                                      property scopes

                                                                                                                      static readonly scopes: string[];
                                                                                                                      • The scopes needed to make gRPC calls for every method defined in this service.

                                                                                                                        Returns

                                                                                                                        {string[]} List of default scopes.

                                                                                                                      property servicePath

                                                                                                                      static readonly servicePath: string;
                                                                                                                      • The DNS address for this API service.

                                                                                                                        Returns

                                                                                                                        {string} The DNS address for this service.

                                                                                                                      property warn

                                                                                                                      warn: (code: string, message: string, warnType?: string) => void;

                                                                                                                        method close

                                                                                                                        close: () => Promise<void>;
                                                                                                                        • Terminate the gRPC channel and close the client.

                                                                                                                          The client will no longer be usable and all future behavior is undefined.

                                                                                                                          Returns

                                                                                                                          {Promise} A promise that resolves when the client is closed.

                                                                                                                        method getLocation

                                                                                                                        getLocation: {
                                                                                                                        (
                                                                                                                        request?: protos.google.cloud.location.IGetLocationRequest,
                                                                                                                        options?: gax.CallOptions
                                                                                                                        ): Promise<protos.google.cloud.location.ILocation>;
                                                                                                                        (
                                                                                                                        request: protos.google.cloud.location.IGetLocationRequest,
                                                                                                                        options: gax.CallOptions,
                                                                                                                        callback: Callback<
                                                                                                                        protos.google.cloud.location.ILocation,
                                                                                                                        protos.google.cloud.location.IGetLocationRequest,
                                                                                                                        {}
                                                                                                                        >
                                                                                                                        ): void;
                                                                                                                        (
                                                                                                                        request: protos.google.cloud.location.IGetLocationRequest,
                                                                                                                        callback: Callback<
                                                                                                                        protos.google.cloud.location.ILocation,
                                                                                                                        protos.google.cloud.location.IGetLocationRequest,
                                                                                                                        {}
                                                                                                                        >
                                                                                                                        ): void;
                                                                                                                        (request: protos.google.cloud.location.IGetLocationRequest): void;
                                                                                                                        (
                                                                                                                        request: protos.google.cloud.location.IGetLocationRequest,
                                                                                                                        options?:
                                                                                                                        | gax.CallOptions
                                                                                                                        | Callback<
                                                                                                                        protos.google.cloud.location.ILocation,
                                                                                                                        protos.google.cloud.location.IGetLocationRequest,
                                                                                                                        {}
                                                                                                                        >,
                                                                                                                        callback?: Callback<
                                                                                                                        protos.google.cloud.location.ILocation,
                                                                                                                        protos.google.cloud.location.IGetLocationRequest,
                                                                                                                        {}
                                                                                                                        >
                                                                                                                        ): Promise<protos.google.cloud.location.ILocation>;
                                                                                                                        };

                                                                                                                          method getProjectId

                                                                                                                          getProjectId: {
                                                                                                                          (): Promise<string>;
                                                                                                                          (callback: Callback<string, undefined, undefined>): void;
                                                                                                                          };
                                                                                                                          • Return the project ID used by this class.

                                                                                                                            Returns

                                                                                                                            {Promise} A promise that resolves to string containing the project ID.

                                                                                                                          method initialize

                                                                                                                          initialize: () => Promise<{ [name: string]: Function }>;
                                                                                                                          • Initialize the client. Performs asynchronous operations (such as authentication) and prepares the client. This function will be called automatically when any class method is called for the first time, but if you need to initialize it before calling an actual method, feel free to call initialize() directly.

                                                                                                                            You can await on this method if you want to make sure the client is initialized.

                                                                                                                            Returns

                                                                                                                            {Promise} A promise that resolves to an authenticated service stub.

                                                                                                                          method listLocations

                                                                                                                          listLocations: {
                                                                                                                          (
                                                                                                                          request?: protos.google.cloud.location.IListLocationsRequest,
                                                                                                                          options?: gax.CallOptions
                                                                                                                          ): Promise<
                                                                                                                          [
                                                                                                                          protos.google.cloud.location.ILocation[],
                                                                                                                          protos.google.cloud.location.IListLocationsRequest | null,
                                                                                                                          protos.google.cloud.location.IListLocationsResponse
                                                                                                                          ]
                                                                                                                          >;
                                                                                                                          (
                                                                                                                          request: protos.google.cloud.location.IListLocationsRequest,
                                                                                                                          options: gax.CallOptions,
                                                                                                                          callback: PaginationCallback<
                                                                                                                          protos.google.cloud.location.IListLocationsRequest,
                                                                                                                          protos.google.cloud.location.IListLocationsResponse,
                                                                                                                          protos.google.cloud.location.ILocation
                                                                                                                          >
                                                                                                                          ): void;
                                                                                                                          (
                                                                                                                          request: protos.google.cloud.location.IListLocationsRequest,
                                                                                                                          callback: PaginationCallback<
                                                                                                                          protos.google.cloud.location.IListLocationsRequest,
                                                                                                                          protos.google.cloud.location.IListLocationsResponse,
                                                                                                                          protos.google.cloud.location.ILocation
                                                                                                                          >
                                                                                                                          ): void;
                                                                                                                          };

                                                                                                                            class LongrunningDescriptor

                                                                                                                            class LongRunningDescriptor implements Descriptor {}
                                                                                                                            • A descriptor for long-running operations.

                                                                                                                            constructor

                                                                                                                            constructor(
                                                                                                                            operationsClient: OperationsClient,
                                                                                                                            responseDecoder: AnyDecoder,
                                                                                                                            metadataDecoder: AnyDecoder
                                                                                                                            );

                                                                                                                              property metadataDecoder

                                                                                                                              metadataDecoder: AnyDecoder;

                                                                                                                                property operationsClient

                                                                                                                                operationsClient: OperationsClient;

                                                                                                                                  property responseDecoder

                                                                                                                                  responseDecoder: AnyDecoder;

                                                                                                                                    method getApiCaller

                                                                                                                                    getApiCaller: () => LongrunningApiCaller;

                                                                                                                                      class OngoingCall

                                                                                                                                      class OngoingCall {}

                                                                                                                                        constructor

                                                                                                                                        constructor(callback: APICallback);
                                                                                                                                        • OngoingCall manages callback, API calls, and cancellation of the API calls.

                                                                                                                                          Parameter callback

                                                                                                                                          The callback to be called asynchronously when the API call finishes. {APICallback} callback The callback function to be called.

                                                                                                                                        property callback

                                                                                                                                        callback: APICallback;

                                                                                                                                          property cancelFunc

                                                                                                                                          cancelFunc?: () => void;

                                                                                                                                            property completed

                                                                                                                                            completed: boolean;

                                                                                                                                              method call

                                                                                                                                              call: (func: SimpleCallbackFunction, argument: RequestType) => void;
                                                                                                                                              • Call calls the specified function. Result will be used to fulfill the promise.

                                                                                                                                                Parameter func

                                                                                                                                                A function for an API call.

                                                                                                                                                Parameter argument

                                                                                                                                                A request object.

                                                                                                                                              method cancel

                                                                                                                                              cancel: () => void;
                                                                                                                                              • Cancels the ongoing promise.

                                                                                                                                              class Operation

                                                                                                                                              class Operation extends EventEmitter {}

                                                                                                                                                constructor

                                                                                                                                                constructor(
                                                                                                                                                grpcOp: operationProtos.google.longrunning.Operation,
                                                                                                                                                longrunningDescriptor: LongRunningDescriptor,
                                                                                                                                                backoffSettings: BackoffSettings,
                                                                                                                                                callOptions?: CallOptions
                                                                                                                                                );
                                                                                                                                                • Wrapper for a google.longrunnung.Operation.

                                                                                                                                                  Parameter grpcOp

                                                                                                                                                  The operation to be wrapped.

                                                                                                                                                  Parameter longrunningDescriptor

                                                                                                                                                  This defines the operations service client and unpacking mechanisms for the operation.

                                                                                                                                                  Parameter backoffSettings

                                                                                                                                                  The backoff settings used in in polling the operation.

                                                                                                                                                  Parameter callOptions

                                                                                                                                                  CallOptions used in making get operation requests.

                                                                                                                                                property backoffSettings

                                                                                                                                                backoffSettings: BackoffSettings;

                                                                                                                                                  property completeListeners

                                                                                                                                                  completeListeners: number;

                                                                                                                                                    property currentCallPromise_

                                                                                                                                                    currentCallPromise_?: CancellablePromise<ResultTuple>;

                                                                                                                                                      property done

                                                                                                                                                      done?: boolean;

                                                                                                                                                        property error

                                                                                                                                                        error?: GoogleError;

                                                                                                                                                          property hasActiveListeners

                                                                                                                                                          hasActiveListeners: boolean;

                                                                                                                                                            property latestResponse

                                                                                                                                                            latestResponse: operationProtos.google.longrunning.Operation;

                                                                                                                                                              property longrunningDescriptor

                                                                                                                                                              longrunningDescriptor: LongRunningDescriptor;

                                                                                                                                                                property metadata

                                                                                                                                                                metadata: Metadata;

                                                                                                                                                                  property name

                                                                                                                                                                  name?: string;

                                                                                                                                                                    property response

                                                                                                                                                                    response?: {};

                                                                                                                                                                      property result

                                                                                                                                                                      result: {};

                                                                                                                                                                        method cancel

                                                                                                                                                                        cancel: () => Promise<operationProtos.google.protobuf.Empty>;
                                                                                                                                                                        • Cancels current polling api call and cancels the operation.

                                                                                                                                                                          {Promise} the promise of the OperationsClient#cancelOperation api request.

                                                                                                                                                                        method getOperation

                                                                                                                                                                        getOperation: { (): Promise<{}>; (callback: GetOperationCallback): void };
                                                                                                                                                                        • Get the updated status of the operation. If the Operation has previously completed, this will use the status of the cached completed operation.

                                                                                                                                                                          - callback(err): Operation failed - callback(null, result, metadata, rawResponse): Operation complete - callback(null, null, metadata, rawResponse): Operation incomplete

                                                                                                                                                                          Parameter callback

                                                                                                                                                                          Callback to handle the polled operation result and metadata. {Promise|undefined} - This returns a promise if a callback is not specified. The promise resolves to an array where the first element is the unpacked result, the second element is the metadata, and the third element is the raw response of the api call. The promise rejects if the operation returns an error.

                                                                                                                                                                        method promise

                                                                                                                                                                        promise: () => Promise<unknown>;
                                                                                                                                                                        • Wraps the complete and error events in a Promise.

                                                                                                                                                                          {promise} - Promise that resolves on operation completion and rejects on operation error.

                                                                                                                                                                        method startPolling_

                                                                                                                                                                        startPolling_: () => void;
                                                                                                                                                                        • Poll getOperation to check the operation's status. This runs a loop to ping using the backoff strategy specified at initialization.

                                                                                                                                                                          Note: This method is automatically called once a "complete" event handler is registered on the operation.

                                                                                                                                                                        class OperationsClient

                                                                                                                                                                        class OperationsClient {}
                                                                                                                                                                        • Manages long-running operations with an API service.

                                                                                                                                                                          When an API method normally takes long time to complete, it can be designed to return Operation to the client, and the client can use this interface to receive the real response asynchronously by polling the operation resource, or pass the operation resource to another API (such as Google Cloud Pub/Sub API) to receive the response. Any API service that returns long-running operations should implement the Operations interface so developers can have a consistent client experience.

                                                                                                                                                                          This will be created through a builder function which can be obtained by the module. See the following example of how to initialize the module and how to access to the builder.

                                                                                                                                                                          See Also

                                                                                                                                                                        constructor

                                                                                                                                                                        constructor(
                                                                                                                                                                        gaxGrpc: GrpcClient | FallbackGrpcClient,
                                                                                                                                                                        operationsProtos: any,
                                                                                                                                                                        options: ClientOptions
                                                                                                                                                                        );

                                                                                                                                                                          property auth

                                                                                                                                                                          auth?: any;

                                                                                                                                                                            property descriptor

                                                                                                                                                                            descriptor: { [method: string]: PageDescriptor };

                                                                                                                                                                              property innerApiCalls

                                                                                                                                                                              innerApiCalls: { [name: string]: Function };

                                                                                                                                                                                property operationsStub

                                                                                                                                                                                operationsStub: Promise<{ [method: string]: Function }>;

                                                                                                                                                                                  method cancelOperation

                                                                                                                                                                                  cancelOperation: (
                                                                                                                                                                                  request: protos.google.longrunning.CancelOperationRequest,
                                                                                                                                                                                  optionsOrCallback?:
                                                                                                                                                                                  | gax.CallOptions
                                                                                                                                                                                  | Callback<
                                                                                                                                                                                  protos.google.protobuf.Empty,
                                                                                                                                                                                  protos.google.longrunning.CancelOperationRequest,
                                                                                                                                                                                  {} | undefined | null
                                                                                                                                                                                  >,
                                                                                                                                                                                  callback?: Callback<
                                                                                                                                                                                  protos.google.longrunning.CancelOperationRequest,
                                                                                                                                                                                  protos.google.protobuf.Empty,
                                                                                                                                                                                  {} | undefined | null
                                                                                                                                                                                  >
                                                                                                                                                                                  ) => Promise<protos.google.protobuf.Empty>;
                                                                                                                                                                                  • Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns google.rpc.Code.UNIMPLEMENTED. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of 1, corresponding to Code.CANCELLED.

                                                                                                                                                                                    Parameter request

                                                                                                                                                                                    The request object that will be sent.

                                                                                                                                                                                    Parameter

                                                                                                                                                                                    {string} request.name - The name of the operation resource to be cancelled.

                                                                                                                                                                                    Parameter options

                                                                                                                                                                                    Optional parameters. You can override the default settings for this call, e.g, timeout, retries, paginations, etc. See [gax.CallOptions]https://googleapis.github.io/gax-nodejs/global.html#CallOptions for the details.

                                                                                                                                                                                    Parameter callback

                                                                                                                                                                                    The function which will be called with the result of the API call. {Promise} - The promise which resolves when API call finishes. The promise has a method named "cancel" which cancels the ongoing API call.

                                                                                                                                                                                    Example 1

                                                                                                                                                                                    const client = longrunning.operationsClient(); await client.cancelOperation({name: ''});

                                                                                                                                                                                  method close

                                                                                                                                                                                  close: () => void;
                                                                                                                                                                                  • Closes this operations client.

                                                                                                                                                                                  method deleteOperation

                                                                                                                                                                                  deleteOperation: (
                                                                                                                                                                                  request: protos.google.longrunning.DeleteOperationRequest,
                                                                                                                                                                                  optionsOrCallback?:
                                                                                                                                                                                  | gax.CallOptions
                                                                                                                                                                                  | Callback<
                                                                                                                                                                                  protos.google.protobuf.Empty,
                                                                                                                                                                                  protos.google.longrunning.DeleteOperationRequest,
                                                                                                                                                                                  {} | null | undefined
                                                                                                                                                                                  >,
                                                                                                                                                                                  callback?: Callback<
                                                                                                                                                                                  protos.google.protobuf.Empty,
                                                                                                                                                                                  protos.google.longrunning.DeleteOperationRequest,
                                                                                                                                                                                  {} | null | undefined
                                                                                                                                                                                  >
                                                                                                                                                                                  ) => Promise<protos.google.protobuf.Empty>;
                                                                                                                                                                                  • Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns google.rpc.Code.UNIMPLEMENTED.

                                                                                                                                                                                    Parameter request

                                                                                                                                                                                    The request object that will be sent.

                                                                                                                                                                                    Parameter

                                                                                                                                                                                    {string} request.name - The name of the operation resource to be deleted.

                                                                                                                                                                                    Parameter options

                                                                                                                                                                                    Optional parameters. You can override the default settings for this call, e.g, timeout, retries, paginations, etc. See [gax.CallOptions]https://googleapis.github.io/gax-nodejs/global.html#CallOptions for the details.

                                                                                                                                                                                    Parameter callback

                                                                                                                                                                                    The function which will be called with the result of the API call. {Promise} - The promise which resolves when API call finishes. The promise has a method named "cancel" which cancels the ongoing API call.

                                                                                                                                                                                    Example 1

                                                                                                                                                                                    const client = longrunning.operationsClient(); await client.deleteOperation({name: ''});

                                                                                                                                                                                  method getOperation

                                                                                                                                                                                  getOperation: (
                                                                                                                                                                                  request: protos.google.longrunning.GetOperationRequest,
                                                                                                                                                                                  optionsOrCallback?:
                                                                                                                                                                                  | gax.CallOptions
                                                                                                                                                                                  | Callback<
                                                                                                                                                                                  protos.google.longrunning.Operation,
                                                                                                                                                                                  protos.google.longrunning.GetOperationRequest,
                                                                                                                                                                                  {} | null | undefined
                                                                                                                                                                                  >,
                                                                                                                                                                                  callback?: Callback<
                                                                                                                                                                                  protos.google.longrunning.Operation,
                                                                                                                                                                                  protos.google.longrunning.GetOperationRequest,
                                                                                                                                                                                  {} | null | undefined
                                                                                                                                                                                  >
                                                                                                                                                                                  ) => Promise<[protos.google.longrunning.Operation]>;
                                                                                                                                                                                  • Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.

                                                                                                                                                                                    Parameter request

                                                                                                                                                                                    The request object that will be sent.

                                                                                                                                                                                    Parameter

                                                                                                                                                                                    {string} request.name - The name of the operation resource.

                                                                                                                                                                                    Parameter options

                                                                                                                                                                                    Optional parameters. You can override the default settings for this call, e.g, timeout, retries, paginations, etc. See [gax.CallOptions]https://googleapis.github.io/gax-nodejs/global.html#CallOptions for the details.

                                                                                                                                                                                    Parameter callback

                                                                                                                                                                                    The function which will be called with the result of the API call.

                                                                                                                                                                                    The second parameter to the callback is an object representing [google.longrunning.Operation]. {Promise} - The promise which resolves to an array. The first element of the array is an object representing [google.longrunning.Operation]. The promise has a method named "cancel" which cancels the ongoing API call.

                                                                                                                                                                                    Example 1

                                                                                                                                                                                    const client = longrunning.operationsClient(); const name = ''; const [response] = await client.getOperation({name}); // doThingsWith(response)

                                                                                                                                                                                  method getOperationInternal

                                                                                                                                                                                  getOperationInternal: (
                                                                                                                                                                                  request: protos.google.longrunning.GetOperationRequest,
                                                                                                                                                                                  options?: gax.CallOptions,
                                                                                                                                                                                  callback?: Callback<
                                                                                                                                                                                  protos.google.longrunning.Operation,
                                                                                                                                                                                  protos.google.longrunning.GetOperationRequest,
                                                                                                                                                                                  {} | null | undefined
                                                                                                                                                                                  >
                                                                                                                                                                                  ) => CancellablePromise<ResultTuple>;

                                                                                                                                                                                    method getProjectId

                                                                                                                                                                                    getProjectId: { (): Promise<string>; (callback: any): void };
                                                                                                                                                                                    • Get the project ID used by this class.

                                                                                                                                                                                      Parameter callback

                                                                                                                                                                                      the callback to be called with the current project Id.

                                                                                                                                                                                    method listOperations

                                                                                                                                                                                    listOperations: (
                                                                                                                                                                                    request: protos.google.longrunning.ListOperationsRequest,
                                                                                                                                                                                    optionsOrCallback?:
                                                                                                                                                                                    | gax.CallOptions
                                                                                                                                                                                    | Callback<
                                                                                                                                                                                    protos.google.longrunning.ListOperationsResponse,
                                                                                                                                                                                    protos.google.longrunning.ListOperationsRequest,
                                                                                                                                                                                    {} | null | undefined
                                                                                                                                                                                    >,
                                                                                                                                                                                    callback?: Callback<
                                                                                                                                                                                    protos.google.longrunning.ListOperationsResponse,
                                                                                                                                                                                    protos.google.longrunning.ListOperationsRequest,
                                                                                                                                                                                    {} | null | undefined
                                                                                                                                                                                    >
                                                                                                                                                                                    ) => Promise<protos.google.longrunning.ListOperationsResponse>;
                                                                                                                                                                                    • Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns UNIMPLEMENTED.

                                                                                                                                                                                      NOTE: the name binding below allows API services to override the binding to use different resource name schemes.

                                                                                                                                                                                      Parameter request

                                                                                                                                                                                      The request object that will be sent.

                                                                                                                                                                                      Parameter

                                                                                                                                                                                      {string} request.name - The name of the operation collection.

                                                                                                                                                                                      Parameter

                                                                                                                                                                                      {string} request.filter - The standard list filter.

                                                                                                                                                                                      Parameter

                                                                                                                                                                                      {number=} request.pageSize The maximum number of resources contained in the underlying API response. If page streaming is performed per-resource, this parameter does not affect the return value. If page streaming is performed per-page, this determines the maximum number of resources in a page.

                                                                                                                                                                                      Parameter options

                                                                                                                                                                                      Optional parameters. You can override the default settings for this call, e.g, timeout, retries, paginations, etc. See [gax.CallOptions]https://googleapis.github.io/gax-nodejs/global.html#CallOptions for the details.

                                                                                                                                                                                      Parameter callback

                                                                                                                                                                                      The function which will be called with the result of the API call.

                                                                                                                                                                                      The second parameter to the callback is Array of [google.longrunning.Operation].

                                                                                                                                                                                      When autoPaginate: false is specified through options, it contains the result in a single response. If the response indicates the next page exists, the third parameter is set to be used for the next request object. The fourth parameter keeps the raw response object of an object representing [google.longrunning.ListOperationsResponse]. {Promise} - The promise which resolves to an array. The first element of the array is Array of [google.longrunning.Operation].

                                                                                                                                                                                      When autoPaginate: false is specified through options, the array has three elements. The first element is Array of [google.longrunning.Operation] in a single response. The second element is the next request object if the response indicates the next page exists, or null. The third element is an object representing [google.longrunning.ListOperationsResponse].

                                                                                                                                                                                      The promise has a method named "cancel" which cancels the ongoing API call.

                                                                                                                                                                                      Example 1

                                                                                                                                                                                      const client = longrunning.operationsClient(); const request = { name: '', filter: '' }; // Iterate over all elements. const [resources] = await client.listOperations(request); for (const resource of resources) { console.log(resources); }

                                                                                                                                                                                      // Or obtain the paged response. const options = {autoPaginate: false}; let nextRequest = request; while(nextRequest) { const response = await client.listOperations(nextRequest, options); const resources = response[0]; nextRequest = response[1]; const rawResponse = response[2]; for (const resource of resources) { // doThingsWith(resource); } };

                                                                                                                                                                                    method listOperationsAsync

                                                                                                                                                                                    listOperationsAsync: (
                                                                                                                                                                                    request: protos.google.longrunning.ListOperationsRequest,
                                                                                                                                                                                    options?: gax.CallOptions
                                                                                                                                                                                    ) => AsyncIterable<protos.google.longrunning.ListOperationsResponse>;
                                                                                                                                                                                    • Equivalent to listOperations, but returns an iterable object.

                                                                                                                                                                                      for-await-of syntax is used with the iterable to recursively get response element on-demand.

                                                                                                                                                                                      Parameter request

                                                                                                                                                                                      The request object that will be sent.

                                                                                                                                                                                      Parameter

                                                                                                                                                                                      {string} request.name - The name of the operation collection.

                                                                                                                                                                                      Parameter

                                                                                                                                                                                      {string} request.filter - The standard list filter.

                                                                                                                                                                                      Parameter

                                                                                                                                                                                      {number=} request.pageSize - The maximum number of resources contained in the underlying API response. If page streaming is performed per-resource, this parameter does not affect the return value. If page streaming is performed per-page, this determines the maximum number of resources in a page.

                                                                                                                                                                                      Parameter options

                                                                                                                                                                                      Optional parameters. You can override the default settings for this call, e.g, timeout, retries, paginations, etc. See [gax.CallOptions]https://googleapis.github.io/gax-nodejs/global.html#CallOptions for the details.

                                                                                                                                                                                      Returns

                                                                                                                                                                                      {Object} An iterable Object that conforms to https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols.

                                                                                                                                                                                    method listOperationsStream

                                                                                                                                                                                    listOperationsStream: (
                                                                                                                                                                                    request: protos.google.longrunning.ListOperationsRequest,
                                                                                                                                                                                    options?: gax.CallOptions
                                                                                                                                                                                    ) => any;
                                                                                                                                                                                    • Equivalent to listOperations, but returns a NodeJS Stream object.

                                                                                                                                                                                      This fetches the paged responses for listOperations continuously and invokes the callback registered for 'data' event for each element in the responses.

                                                                                                                                                                                      The returned object has 'end' method when no more elements are required.

                                                                                                                                                                                      autoPaginate option will be ignored.

                                                                                                                                                                                      Parameter request

                                                                                                                                                                                      The request object that will be sent.

                                                                                                                                                                                      Parameter

                                                                                                                                                                                      {string} request.name - The name of the operation collection.

                                                                                                                                                                                      Parameter

                                                                                                                                                                                      {string} request.filter - The standard list filter.

                                                                                                                                                                                      Parameter

                                                                                                                                                                                      {number=} request.pageSize - The maximum number of resources contained in the underlying API response. If page streaming is performed per-resource, this parameter does not affect the return value. If page streaming is performed per-page, this determines the maximum number of resources in a page.

                                                                                                                                                                                      Parameter options

                                                                                                                                                                                      Optional parameters. You can override the default settings for this call, e.g, timeout, retries, paginations, etc. See [gax.CallOptions]https://googleapis.github.io/gax-nodejs/global.html#CallOptions for the details. {Stream} - An object stream which emits an object representing [google.longrunning.Operation] on 'data' event.

                                                                                                                                                                                      Example 1

                                                                                                                                                                                      const client = longrunning.operationsClient(); const request = { name: '', filter: '' }; client.listOperationsStream(request) .on('data', element => { // doThingsWith(element) }) .on('error', err => { console.error(err); });

                                                                                                                                                                                      See Also

                                                                                                                                                                                    class PageDescriptor

                                                                                                                                                                                    class PageDescriptor implements Descriptor {}
                                                                                                                                                                                    • A descriptor for methods that support pagination.

                                                                                                                                                                                    constructor

                                                                                                                                                                                    constructor(
                                                                                                                                                                                    requestPageTokenField: string,
                                                                                                                                                                                    responsePageTokenField: string,
                                                                                                                                                                                    resourceField: string
                                                                                                                                                                                    );

                                                                                                                                                                                      property requestPageSizeField

                                                                                                                                                                                      requestPageSizeField?: string;

                                                                                                                                                                                        property requestPageTokenField

                                                                                                                                                                                        requestPageTokenField: string;

                                                                                                                                                                                          property resourceField

                                                                                                                                                                                          resourceField: string;

                                                                                                                                                                                            property responsePageTokenField

                                                                                                                                                                                            responsePageTokenField: string;

                                                                                                                                                                                              method asyncIterate

                                                                                                                                                                                              asyncIterate: (
                                                                                                                                                                                              apiCall: GaxCall,
                                                                                                                                                                                              request: RequestType,
                                                                                                                                                                                              options?: CallSettings
                                                                                                                                                                                              ) => AsyncIterable<{} | undefined>;
                                                                                                                                                                                              • Create an async iterable which can be recursively called for data on-demand.

                                                                                                                                                                                              method createIterator

                                                                                                                                                                                              createIterator: (
                                                                                                                                                                                              apiCall: GaxCall,
                                                                                                                                                                                              request: RequestType,
                                                                                                                                                                                              options: CallSettings
                                                                                                                                                                                              ) => AsyncIterable<{} | undefined>;

                                                                                                                                                                                                method createStream

                                                                                                                                                                                                createStream: (apiCall: GaxCall, request: {}, options: CallSettings) => any;
                                                                                                                                                                                                • Creates a new object Stream which emits the resource on 'data' event.

                                                                                                                                                                                                method getApiCaller

                                                                                                                                                                                                getApiCaller: (settings: CallSettings) => APICaller;

                                                                                                                                                                                                  class PathTemplate

                                                                                                                                                                                                  class PathTemplate {}

                                                                                                                                                                                                    constructor

                                                                                                                                                                                                    constructor(data: string);
                                                                                                                                                                                                    • Parameter data

                                                                                                                                                                                                      the of the template

                                                                                                                                                                                                    property segments

                                                                                                                                                                                                    segments: string[];

                                                                                                                                                                                                      property size

                                                                                                                                                                                                      size: number;

                                                                                                                                                                                                        method inspect

                                                                                                                                                                                                        inspect: () => string;
                                                                                                                                                                                                        • Renders the path template.

                                                                                                                                                                                                          {string} contains const names matched to binding values

                                                                                                                                                                                                        method match

                                                                                                                                                                                                        match: (path: string) => Bindings;
                                                                                                                                                                                                        • Matches a fully-qualified path template string.

                                                                                                                                                                                                          Parameter path

                                                                                                                                                                                                          a fully-qualified path template string {Object} contains const names matched to binding values

                                                                                                                                                                                                          Throws

                                                                                                                                                                                                          {TypeError} if path can't be matched to this template

                                                                                                                                                                                                        method render

                                                                                                                                                                                                        render: (bindings: Bindings) => string;
                                                                                                                                                                                                        • Renders a path template using the provided bindings.

                                                                                                                                                                                                          Parameter bindings

                                                                                                                                                                                                          a mapping of const names to binding strings {String} a rendered representation of the path template

                                                                                                                                                                                                          Throws

                                                                                                                                                                                                          {TypeError} if a key is missing, or if a sub-template cannot be parsed

                                                                                                                                                                                                        class RetryOptions

                                                                                                                                                                                                        class RetryOptions {}
                                                                                                                                                                                                        • Per-call configurable settings for retrying upon transient failure. {Object} RetryOptions {String[]} retryCodes {BackoffSettings} backoffSettings

                                                                                                                                                                                                        constructor

                                                                                                                                                                                                        constructor(retryCodes: number[], backoffSettings: BackoffSettings);

                                                                                                                                                                                                          property backoffSettings

                                                                                                                                                                                                          backoffSettings: BackoffSettings;

                                                                                                                                                                                                            property retryCodes

                                                                                                                                                                                                            retryCodes: number[];

                                                                                                                                                                                                              class StreamDescriptor

                                                                                                                                                                                                              class StreamDescriptor implements Descriptor {}
                                                                                                                                                                                                              • A descriptor for streaming calls.

                                                                                                                                                                                                              constructor

                                                                                                                                                                                                              constructor(streamType: StreamType);

                                                                                                                                                                                                                property streaming

                                                                                                                                                                                                                streaming: boolean;

                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                  type: StreamType;

                                                                                                                                                                                                                    method getApiCaller

                                                                                                                                                                                                                    getApiCaller: (settings: CallSettings) => APICaller;

                                                                                                                                                                                                                      Interfaces

                                                                                                                                                                                                                      interface Callback

                                                                                                                                                                                                                      interface Callback<ResponseObject, NextRequestObject, RawResponseObject> {}

                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                        (
                                                                                                                                                                                                                        err: Error | null | undefined,
                                                                                                                                                                                                                        value?: ResponseObject | null,
                                                                                                                                                                                                                        nextRequest?: NextRequestObject,
                                                                                                                                                                                                                        rawResponse?: RawResponseObject
                                                                                                                                                                                                                        ): void;

                                                                                                                                                                                                                          interface CallOptions

                                                                                                                                                                                                                          interface CallOptions {}

                                                                                                                                                                                                                            property apiName

                                                                                                                                                                                                                            apiName?: string;

                                                                                                                                                                                                                              property autoPaginate

                                                                                                                                                                                                                              autoPaginate?: boolean;

                                                                                                                                                                                                                                property bundleOptions

                                                                                                                                                                                                                                bundleOptions?: BundleOptions | null;

                                                                                                                                                                                                                                  property isBundling

                                                                                                                                                                                                                                  isBundling?: boolean;

                                                                                                                                                                                                                                    property longrunning

                                                                                                                                                                                                                                    longrunning?: BackoffSettings;

                                                                                                                                                                                                                                      property maxResults

                                                                                                                                                                                                                                      maxResults?: number;

                                                                                                                                                                                                                                        property maxRetries

                                                                                                                                                                                                                                        maxRetries?: number;

                                                                                                                                                                                                                                          property otherArgs

                                                                                                                                                                                                                                          otherArgs?: {
                                                                                                                                                                                                                                          [index: string]: any;
                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                            property pageSize

                                                                                                                                                                                                                                            pageSize?: number;

                                                                                                                                                                                                                                              property pageToken

                                                                                                                                                                                                                                              pageToken?: string;

                                                                                                                                                                                                                                                property retry

                                                                                                                                                                                                                                                retry?: Partial<RetryOptions> | null;

                                                                                                                                                                                                                                                  property retryRequestOptions

                                                                                                                                                                                                                                                  retryRequestOptions?: RetryRequestOptions;

                                                                                                                                                                                                                                                    property timeout

                                                                                                                                                                                                                                                    timeout?: number;

                                                                                                                                                                                                                                                      interface CancellablePromise

                                                                                                                                                                                                                                                      interface CancellablePromise<T> extends Promise<T> {}

                                                                                                                                                                                                                                                        method cancel

                                                                                                                                                                                                                                                        cancel: () => void;

                                                                                                                                                                                                                                                          interface ClientConfig

                                                                                                                                                                                                                                                          interface ClientConfig {}

                                                                                                                                                                                                                                                            property interfaces

                                                                                                                                                                                                                                                            interfaces?: {
                                                                                                                                                                                                                                                            [index: string]: ServiceConfig;
                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                              interface ClientOptions

                                                                                                                                                                                                                                                              interface ClientOptions
                                                                                                                                                                                                                                                              extends GrpcClientOptions,
                                                                                                                                                                                                                                                              GoogleAuthOptions,
                                                                                                                                                                                                                                                              ClientStubOptions {}

                                                                                                                                                                                                                                                                property apiEndpoint

                                                                                                                                                                                                                                                                apiEndpoint?: string;

                                                                                                                                                                                                                                                                  property clientConfig

                                                                                                                                                                                                                                                                  clientConfig?: gax.ClientConfig;

                                                                                                                                                                                                                                                                    property fallback

                                                                                                                                                                                                                                                                    fallback?: boolean | 'rest' | 'proto';

                                                                                                                                                                                                                                                                      property libName

                                                                                                                                                                                                                                                                      libName?: string;

                                                                                                                                                                                                                                                                        property libVersion

                                                                                                                                                                                                                                                                        libVersion?: string;

                                                                                                                                                                                                                                                                          interface ClientStubOptions

                                                                                                                                                                                                                                                                          interface ClientStubOptions {}

                                                                                                                                                                                                                                                                            property cert

                                                                                                                                                                                                                                                                            cert?: string;

                                                                                                                                                                                                                                                                              property key

                                                                                                                                                                                                                                                                              key?: string;

                                                                                                                                                                                                                                                                                property port

                                                                                                                                                                                                                                                                                port?: number;

                                                                                                                                                                                                                                                                                  property protocol

                                                                                                                                                                                                                                                                                  protocol?: string;

                                                                                                                                                                                                                                                                                    property servicePath

                                                                                                                                                                                                                                                                                    servicePath?: string;

                                                                                                                                                                                                                                                                                      property sslCreds

                                                                                                                                                                                                                                                                                      sslCreds?: grpc.ChannelCredentials;

                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                        [index: string]: string | number | undefined | {};

                                                                                                                                                                                                                                                                                          interface Descriptors

                                                                                                                                                                                                                                                                                          interface Descriptors {}

                                                                                                                                                                                                                                                                                            property batching

                                                                                                                                                                                                                                                                                            batching?: {
                                                                                                                                                                                                                                                                                            [name: string]: BundleDescriptor;
                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                              property longrunning

                                                                                                                                                                                                                                                                                              longrunning: {
                                                                                                                                                                                                                                                                                              [name: string]: LongrunningDescriptor;
                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                property page

                                                                                                                                                                                                                                                                                                page: {
                                                                                                                                                                                                                                                                                                [name: string]: PageDescriptor;
                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                  property stream

                                                                                                                                                                                                                                                                                                  stream: {
                                                                                                                                                                                                                                                                                                  [name: string]: StreamDescriptor;
                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                    interface GaxCall

                                                                                                                                                                                                                                                                                                    interface GaxCall {}

                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                      (argument: {}, callOptions?: CallOptions, callback?: APICallback): GaxCallResult;

                                                                                                                                                                                                                                                                                                        interface GRPCCallResult

                                                                                                                                                                                                                                                                                                        interface GRPCCallResult {}

                                                                                                                                                                                                                                                                                                          method cancel

                                                                                                                                                                                                                                                                                                          cancel: () => void;

                                                                                                                                                                                                                                                                                                            interface GrpcClientOptions

                                                                                                                                                                                                                                                                                                            interface GrpcClientOptions extends GoogleAuthOptions {}

                                                                                                                                                                                                                                                                                                              property auth

                                                                                                                                                                                                                                                                                                              auth?: GoogleAuth;

                                                                                                                                                                                                                                                                                                                property grpc

                                                                                                                                                                                                                                                                                                                grpc?: GrpcModule;

                                                                                                                                                                                                                                                                                                                  interface IamClient

                                                                                                                                                                                                                                                                                                                  interface IamClient {}

                                                                                                                                                                                                                                                                                                                    method getIamPolicy

                                                                                                                                                                                                                                                                                                                    getIamPolicy: {
                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                    request: protos.google.iam.v1.GetIamPolicyRequest,
                                                                                                                                                                                                                                                                                                                    options?: gax.CallOptions
                                                                                                                                                                                                                                                                                                                    ): Promise<protos.google.iam.v1.Policy>;
                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                    request: protos.google.iam.v1.GetIamPolicyRequest,
                                                                                                                                                                                                                                                                                                                    options: gax.CallOptions,
                                                                                                                                                                                                                                                                                                                    callback: Callback<
                                                                                                                                                                                                                                                                                                                    protos.google.iam.v1.Policy,
                                                                                                                                                                                                                                                                                                                    protos.google.iam.v1.GetIamPolicyRequest,
                                                                                                                                                                                                                                                                                                                    {}
                                                                                                                                                                                                                                                                                                                    >
                                                                                                                                                                                                                                                                                                                    ): void;
                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                    request: protos.google.iam.v1.GetIamPolicyRequest,
                                                                                                                                                                                                                                                                                                                    callback: Callback<
                                                                                                                                                                                                                                                                                                                    protos.google.iam.v1.Policy,
                                                                                                                                                                                                                                                                                                                    protos.google.iam.v1.GetIamPolicyRequest,
                                                                                                                                                                                                                                                                                                                    {}
                                                                                                                                                                                                                                                                                                                    >
                                                                                                                                                                                                                                                                                                                    ): void;
                                                                                                                                                                                                                                                                                                                    (request: protos.google.iam.v1.GetIamPolicyRequest): void;
                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                    request: protos.google.iam.v1.GetIamPolicyRequest,
                                                                                                                                                                                                                                                                                                                    options?:
                                                                                                                                                                                                                                                                                                                    | gax.CallOptions
                                                                                                                                                                                                                                                                                                                    | Callback<
                                                                                                                                                                                                                                                                                                                    protos.google.iam.v1.Policy,
                                                                                                                                                                                                                                                                                                                    protos.google.iam.v1.GetIamPolicyRequest,
                                                                                                                                                                                                                                                                                                                    {}
                                                                                                                                                                                                                                                                                                                    >,
                                                                                                                                                                                                                                                                                                                    callback?: Callback<
                                                                                                                                                                                                                                                                                                                    protos.google.iam.v1.Policy,
                                                                                                                                                                                                                                                                                                                    protos.google.iam.v1.GetIamPolicyRequest,
                                                                                                                                                                                                                                                                                                                    {}
                                                                                                                                                                                                                                                                                                                    >
                                                                                                                                                                                                                                                                                                                    ): Promise<protos.google.iam.v1.Policy>;
                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                      method setIamPolicy

                                                                                                                                                                                                                                                                                                                      setIamPolicy: {
                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                      request: protos.google.iam.v1.SetIamPolicyRequest,
                                                                                                                                                                                                                                                                                                                      options?: gax.CallOptions
                                                                                                                                                                                                                                                                                                                      ): Promise<protos.google.iam.v1.Policy>;
                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                      request: protos.google.iam.v1.SetIamPolicyRequest,
                                                                                                                                                                                                                                                                                                                      options: gax.CallOptions,
                                                                                                                                                                                                                                                                                                                      callback: Callback<
                                                                                                                                                                                                                                                                                                                      protos.google.iam.v1.Policy,
                                                                                                                                                                                                                                                                                                                      protos.google.iam.v1.SetIamPolicyRequest,
                                                                                                                                                                                                                                                                                                                      {}
                                                                                                                                                                                                                                                                                                                      >
                                                                                                                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                      request: protos.google.iam.v1.SetIamPolicyRequest,
                                                                                                                                                                                                                                                                                                                      callback: Callback<
                                                                                                                                                                                                                                                                                                                      protos.google.iam.v1.Policy,
                                                                                                                                                                                                                                                                                                                      protos.google.iam.v1.SetIamPolicyRequest,
                                                                                                                                                                                                                                                                                                                      {}
                                                                                                                                                                                                                                                                                                                      >
                                                                                                                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                                                                                                                      (request: protos.google.iam.v1.SetIamPolicyRequest): void;
                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                      request: protos.google.iam.v1.SetIamPolicyRequest,
                                                                                                                                                                                                                                                                                                                      options?:
                                                                                                                                                                                                                                                                                                                      | gax.CallOptions
                                                                                                                                                                                                                                                                                                                      | Callback<
                                                                                                                                                                                                                                                                                                                      protos.google.iam.v1.Policy,
                                                                                                                                                                                                                                                                                                                      protos.google.iam.v1.SetIamPolicyRequest,
                                                                                                                                                                                                                                                                                                                      {}
                                                                                                                                                                                                                                                                                                                      >,
                                                                                                                                                                                                                                                                                                                      callback?: Callback<
                                                                                                                                                                                                                                                                                                                      protos.google.iam.v1.Policy,
                                                                                                                                                                                                                                                                                                                      protos.google.iam.v1.SetIamPolicyRequest,
                                                                                                                                                                                                                                                                                                                      {}
                                                                                                                                                                                                                                                                                                                      >
                                                                                                                                                                                                                                                                                                                      ): Promise<protos.google.iam.v1.Policy>;
                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                        method testIamPermissions

                                                                                                                                                                                                                                                                                                                        testIamPermissions: {
                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                        request: protos.google.iam.v1.TestIamPermissionsRequest,
                                                                                                                                                                                                                                                                                                                        options?: gax.CallOptions
                                                                                                                                                                                                                                                                                                                        ): Promise<protos.google.iam.v1.TestIamPermissionsResponse>;
                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                        request: protos.google.iam.v1.TestIamPermissionsRequest,
                                                                                                                                                                                                                                                                                                                        callback: Callback<
                                                                                                                                                                                                                                                                                                                        protos.google.iam.v1.TestIamPermissionsResponse,
                                                                                                                                                                                                                                                                                                                        protos.google.iam.v1.TestIamPermissionsRequest,
                                                                                                                                                                                                                                                                                                                        {}
                                                                                                                                                                                                                                                                                                                        >
                                                                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                        request: protos.google.iam.v1.TestIamPermissionsRequest,
                                                                                                                                                                                                                                                                                                                        options: gax.CallOptions,
                                                                                                                                                                                                                                                                                                                        callback: Callback<
                                                                                                                                                                                                                                                                                                                        protos.google.iam.v1.TestIamPermissionsResponse,
                                                                                                                                                                                                                                                                                                                        protos.google.iam.v1.TestIamPermissionsRequest,
                                                                                                                                                                                                                                                                                                                        {}
                                                                                                                                                                                                                                                                                                                        >
                                                                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                                                                        (request: protos.google.iam.v1.TestIamPermissionsRequest): void;
                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                        request: protos.google.iam.v1.TestIamPermissionsRequest,
                                                                                                                                                                                                                                                                                                                        options?:
                                                                                                                                                                                                                                                                                                                        | gax.CallOptions
                                                                                                                                                                                                                                                                                                                        | Callback<
                                                                                                                                                                                                                                                                                                                        protos.google.iam.v1.TestIamPermissionsResponse,
                                                                                                                                                                                                                                                                                                                        protos.google.iam.v1.TestIamPermissionsRequest,
                                                                                                                                                                                                                                                                                                                        {}
                                                                                                                                                                                                                                                                                                                        >,
                                                                                                                                                                                                                                                                                                                        callback?: Callback<
                                                                                                                                                                                                                                                                                                                        protos.google.iam.v1.TestIamPermissionsResponse,
                                                                                                                                                                                                                                                                                                                        protos.google.iam.v1.TestIamPermissionsRequest,
                                                                                                                                                                                                                                                                                                                        {}
                                                                                                                                                                                                                                                                                                                        >
                                                                                                                                                                                                                                                                                                                        ): Promise<protos.google.iam.v1.TestIamPermissionsResponse>;
                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                          interface LocationsClient

                                                                                                                                                                                                                                                                                                                          interface LocationsClient {}

                                                                                                                                                                                                                                                                                                                            method getLocation

                                                                                                                                                                                                                                                                                                                            getLocation: {
                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                            request?: protos.google.cloud.location.IGetLocationRequest,
                                                                                                                                                                                                                                                                                                                            options?: gax.CallOptions
                                                                                                                                                                                                                                                                                                                            ): Promise<protos.google.cloud.location.ILocation>;
                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                            request: protos.google.cloud.location.IGetLocationRequest,
                                                                                                                                                                                                                                                                                                                            options: gax.CallOptions,
                                                                                                                                                                                                                                                                                                                            callback: Callback<
                                                                                                                                                                                                                                                                                                                            protos.google.cloud.location.ILocation,
                                                                                                                                                                                                                                                                                                                            protos.google.cloud.location.IGetLocationRequest,
                                                                                                                                                                                                                                                                                                                            {}
                                                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                                                            ): void;
                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                            request: protos.google.cloud.location.IGetLocationRequest,
                                                                                                                                                                                                                                                                                                                            callback: Callback<
                                                                                                                                                                                                                                                                                                                            protos.google.cloud.location.ILocation,
                                                                                                                                                                                                                                                                                                                            protos.google.cloud.location.IGetLocationRequest,
                                                                                                                                                                                                                                                                                                                            {}
                                                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                                                            ): void;
                                                                                                                                                                                                                                                                                                                            (request: protos.google.cloud.location.IGetLocationRequest): void;
                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                            request: protos.google.cloud.location.IGetLocationRequest,
                                                                                                                                                                                                                                                                                                                            options?:
                                                                                                                                                                                                                                                                                                                            | gax.CallOptions
                                                                                                                                                                                                                                                                                                                            | Callback<
                                                                                                                                                                                                                                                                                                                            protos.google.cloud.location.ILocation,
                                                                                                                                                                                                                                                                                                                            protos.google.cloud.location.IGetLocationRequest,
                                                                                                                                                                                                                                                                                                                            {}
                                                                                                                                                                                                                                                                                                                            >,
                                                                                                                                                                                                                                                                                                                            callback?: Callback<
                                                                                                                                                                                                                                                                                                                            protos.google.cloud.location.ILocation,
                                                                                                                                                                                                                                                                                                                            protos.google.cloud.location.IGetLocationRequest,
                                                                                                                                                                                                                                                                                                                            {}
                                                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                                                            ): Promise<protos.google.cloud.location.ILocation>;
                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                              method listLocationsAsync

                                                                                                                                                                                                                                                                                                                              listLocationsAsync: (
                                                                                                                                                                                                                                                                                                                              request: protos.google.cloud.location.IListLocationsRequest,
                                                                                                                                                                                                                                                                                                                              options?: gax.CallOptions
                                                                                                                                                                                                                                                                                                                              ) => AsyncIterable<protos.google.cloud.location.ILocation>;

                                                                                                                                                                                                                                                                                                                                interface LROperation

                                                                                                                                                                                                                                                                                                                                interface LROperation<ResultType, MetadataType> extends longrunning.Operation {}

                                                                                                                                                                                                                                                                                                                                  method promise

                                                                                                                                                                                                                                                                                                                                  promise: () => Promise<
                                                                                                                                                                                                                                                                                                                                  [ResultType, MetadataType, operationProtos.google.longrunning.Operation]
                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                    interface Metadata

                                                                                                                                                                                                                                                                                                                                    interface Metadata {}

                                                                                                                                                                                                                                                                                                                                      property clone

                                                                                                                                                                                                                                                                                                                                      clone: () => Metadata;

                                                                                                                                                                                                                                                                                                                                        property get

                                                                                                                                                                                                                                                                                                                                        get: (key: {}) => {};

                                                                                                                                                                                                                                                                                                                                          property set

                                                                                                                                                                                                                                                                                                                                          set: (key: {}, value?: {} | null) => void;

                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                            value: MetadataValue;

                                                                                                                                                                                                                                                                                                                                              construct signature

                                                                                                                                                                                                                                                                                                                                              new (): Metadata;

                                                                                                                                                                                                                                                                                                                                                interface MetadataValue

                                                                                                                                                                                                                                                                                                                                                interface MetadataValue {}

                                                                                                                                                                                                                                                                                                                                                  property equals

                                                                                                                                                                                                                                                                                                                                                  equals: Function;

                                                                                                                                                                                                                                                                                                                                                    interface PaginationCallback

                                                                                                                                                                                                                                                                                                                                                    interface PaginationCallback<RequestObject, ResponseObject, ResponseType> {}

                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                      err: Error | null,
                                                                                                                                                                                                                                                                                                                                                      values?: ResponseType[],
                                                                                                                                                                                                                                                                                                                                                      nextPageRequest?: RequestObject,
                                                                                                                                                                                                                                                                                                                                                      rawResponse?: ResponseObject
                                                                                                                                                                                                                                                                                                                                                      ): void;

                                                                                                                                                                                                                                                                                                                                                        interface PaginationResponse

                                                                                                                                                                                                                                                                                                                                                        interface PaginationResponse<RequestObject, ResponseObject, ResponseType> {}

                                                                                                                                                                                                                                                                                                                                                          property nextPageRequest

                                                                                                                                                                                                                                                                                                                                                          nextPageRequest?: RequestObject;

                                                                                                                                                                                                                                                                                                                                                            property rawResponse

                                                                                                                                                                                                                                                                                                                                                            rawResponse?: ResponseObject;

                                                                                                                                                                                                                                                                                                                                                              property values

                                                                                                                                                                                                                                                                                                                                                              values?: ResponseType[];

                                                                                                                                                                                                                                                                                                                                                                interface ServiceConfig

                                                                                                                                                                                                                                                                                                                                                                interface ServiceConfig {}

                                                                                                                                                                                                                                                                                                                                                                  property methods

                                                                                                                                                                                                                                                                                                                                                                  methods: {
                                                                                                                                                                                                                                                                                                                                                                  [index: string]: MethodConfig | null;
                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                    property retry_codes

                                                                                                                                                                                                                                                                                                                                                                    retry_codes?: {
                                                                                                                                                                                                                                                                                                                                                                    [index: string]: string[];
                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                      property retry_params

                                                                                                                                                                                                                                                                                                                                                                      retry_params?: {
                                                                                                                                                                                                                                                                                                                                                                      [index: string]: RetryParamsConfig;
                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                        Enums

                                                                                                                                                                                                                                                                                                                                                                        enum Status

                                                                                                                                                                                                                                                                                                                                                                        enum Status {
                                                                                                                                                                                                                                                                                                                                                                        OK = 0,
                                                                                                                                                                                                                                                                                                                                                                        CANCELLED = 1,
                                                                                                                                                                                                                                                                                                                                                                        UNKNOWN = 2,
                                                                                                                                                                                                                                                                                                                                                                        INVALID_ARGUMENT = 3,
                                                                                                                                                                                                                                                                                                                                                                        DEADLINE_EXCEEDED = 4,
                                                                                                                                                                                                                                                                                                                                                                        NOT_FOUND = 5,
                                                                                                                                                                                                                                                                                                                                                                        ALREADY_EXISTS = 6,
                                                                                                                                                                                                                                                                                                                                                                        PERMISSION_DENIED = 7,
                                                                                                                                                                                                                                                                                                                                                                        RESOURCE_EXHAUSTED = 8,
                                                                                                                                                                                                                                                                                                                                                                        FAILED_PRECONDITION = 9,
                                                                                                                                                                                                                                                                                                                                                                        ABORTED = 10,
                                                                                                                                                                                                                                                                                                                                                                        OUT_OF_RANGE = 11,
                                                                                                                                                                                                                                                                                                                                                                        UNIMPLEMENTED = 12,
                                                                                                                                                                                                                                                                                                                                                                        INTERNAL = 13,
                                                                                                                                                                                                                                                                                                                                                                        UNAVAILABLE = 14,
                                                                                                                                                                                                                                                                                                                                                                        DATA_LOSS = 15,
                                                                                                                                                                                                                                                                                                                                                                        UNAUTHENTICATED = 16,
                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                        • Copyright 2020 Google LLC

                                                                                                                                                                                                                                                                                                                                                                          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.

                                                                                                                                                                                                                                                                                                                                                                        member ABORTED

                                                                                                                                                                                                                                                                                                                                                                        ABORTED = 10

                                                                                                                                                                                                                                                                                                                                                                          member ALREADY_EXISTS

                                                                                                                                                                                                                                                                                                                                                                          ALREADY_EXISTS = 6

                                                                                                                                                                                                                                                                                                                                                                            member CANCELLED

                                                                                                                                                                                                                                                                                                                                                                            CANCELLED = 1

                                                                                                                                                                                                                                                                                                                                                                              member DATA_LOSS

                                                                                                                                                                                                                                                                                                                                                                              DATA_LOSS = 15

                                                                                                                                                                                                                                                                                                                                                                                member DEADLINE_EXCEEDED

                                                                                                                                                                                                                                                                                                                                                                                DEADLINE_EXCEEDED = 4

                                                                                                                                                                                                                                                                                                                                                                                  member FAILED_PRECONDITION

                                                                                                                                                                                                                                                                                                                                                                                  FAILED_PRECONDITION = 9

                                                                                                                                                                                                                                                                                                                                                                                    member INTERNAL

                                                                                                                                                                                                                                                                                                                                                                                    INTERNAL = 13

                                                                                                                                                                                                                                                                                                                                                                                      member INVALID_ARGUMENT

                                                                                                                                                                                                                                                                                                                                                                                      INVALID_ARGUMENT = 3

                                                                                                                                                                                                                                                                                                                                                                                        member NOT_FOUND

                                                                                                                                                                                                                                                                                                                                                                                        NOT_FOUND = 5

                                                                                                                                                                                                                                                                                                                                                                                          member OK

                                                                                                                                                                                                                                                                                                                                                                                          OK = 0

                                                                                                                                                                                                                                                                                                                                                                                            member OUT_OF_RANGE

                                                                                                                                                                                                                                                                                                                                                                                            OUT_OF_RANGE = 11

                                                                                                                                                                                                                                                                                                                                                                                              member PERMISSION_DENIED

                                                                                                                                                                                                                                                                                                                                                                                              PERMISSION_DENIED = 7

                                                                                                                                                                                                                                                                                                                                                                                                member RESOURCE_EXHAUSTED

                                                                                                                                                                                                                                                                                                                                                                                                RESOURCE_EXHAUSTED = 8

                                                                                                                                                                                                                                                                                                                                                                                                  member UNAUTHENTICATED

                                                                                                                                                                                                                                                                                                                                                                                                  UNAUTHENTICATED = 16

                                                                                                                                                                                                                                                                                                                                                                                                    member UNAVAILABLE

                                                                                                                                                                                                                                                                                                                                                                                                    UNAVAILABLE = 14

                                                                                                                                                                                                                                                                                                                                                                                                      member UNIMPLEMENTED

                                                                                                                                                                                                                                                                                                                                                                                                      UNIMPLEMENTED = 12

                                                                                                                                                                                                                                                                                                                                                                                                        member UNKNOWN

                                                                                                                                                                                                                                                                                                                                                                                                        UNKNOWN = 2

                                                                                                                                                                                                                                                                                                                                                                                                          enum StreamType

                                                                                                                                                                                                                                                                                                                                                                                                          enum StreamType {
                                                                                                                                                                                                                                                                                                                                                                                                          SERVER_STREAMING = 1,
                                                                                                                                                                                                                                                                                                                                                                                                          CLIENT_STREAMING = 2,
                                                                                                                                                                                                                                                                                                                                                                                                          BIDI_STREAMING = 3,
                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                          • The type of gRPC streaming. {number}

                                                                                                                                                                                                                                                                                                                                                                                                          member BIDI_STREAMING

                                                                                                                                                                                                                                                                                                                                                                                                          BIDI_STREAMING = 3
                                                                                                                                                                                                                                                                                                                                                                                                          • Both client and server stream objects.

                                                                                                                                                                                                                                                                                                                                                                                                          member CLIENT_STREAMING

                                                                                                                                                                                                                                                                                                                                                                                                          CLIENT_STREAMING = 2
                                                                                                                                                                                                                                                                                                                                                                                                          • Client streams requests, server returns a single response.

                                                                                                                                                                                                                                                                                                                                                                                                          member SERVER_STREAMING

                                                                                                                                                                                                                                                                                                                                                                                                          SERVER_STREAMING = 1
                                                                                                                                                                                                                                                                                                                                                                                                          • Client sends a single request, server streams responses.

                                                                                                                                                                                                                                                                                                                                                                                                          Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                          type APICallback

                                                                                                                                                                                                                                                                                                                                                                                                          type APICallback = (
                                                                                                                                                                                                                                                                                                                                                                                                          err: GoogleError | null,
                                                                                                                                                                                                                                                                                                                                                                                                          response?: ResponseType,
                                                                                                                                                                                                                                                                                                                                                                                                          next?: NextPageRequestType,
                                                                                                                                                                                                                                                                                                                                                                                                          rawResponse?: RawResponseType
                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                            type BiDiStreamingCall

                                                                                                                                                                                                                                                                                                                                                                                                            type BiDiStreamingCall = (metadata: {}, options: {}) => Duplex & GRPCCallResult;

                                                                                                                                                                                                                                                                                                                                                                                                              type CancellableStream

                                                                                                                                                                                                                                                                                                                                                                                                              type CancellableStream = Duplex & GRPCCallResult;

                                                                                                                                                                                                                                                                                                                                                                                                                type ClientStreamingCall

                                                                                                                                                                                                                                                                                                                                                                                                                type ClientStreamingCall = (
                                                                                                                                                                                                                                                                                                                                                                                                                metadata: {},
                                                                                                                                                                                                                                                                                                                                                                                                                options: {},
                                                                                                                                                                                                                                                                                                                                                                                                                callback?: APICallback
                                                                                                                                                                                                                                                                                                                                                                                                                ) => Duplex & GRPCCallResult;

                                                                                                                                                                                                                                                                                                                                                                                                                  type GRPCCall

                                                                                                                                                                                                                                                                                                                                                                                                                  type GRPCCall =
                                                                                                                                                                                                                                                                                                                                                                                                                  | UnaryCall
                                                                                                                                                                                                                                                                                                                                                                                                                  | ServerStreamingCall
                                                                                                                                                                                                                                                                                                                                                                                                                  | ClientStreamingCall
                                                                                                                                                                                                                                                                                                                                                                                                                  | BiDiStreamingCall;

                                                                                                                                                                                                                                                                                                                                                                                                                    type GrpcModule

                                                                                                                                                                                                                                                                                                                                                                                                                    type GrpcModule = typeof grpc;

                                                                                                                                                                                                                                                                                                                                                                                                                      type ServerStreamingCall

                                                                                                                                                                                                                                                                                                                                                                                                                      type ServerStreamingCall = (
                                                                                                                                                                                                                                                                                                                                                                                                                      argument: {},
                                                                                                                                                                                                                                                                                                                                                                                                                      metadata: {},
                                                                                                                                                                                                                                                                                                                                                                                                                      options: {}
                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Duplex & GRPCCallResult;

                                                                                                                                                                                                                                                                                                                                                                                                                        type UnaryCall

                                                                                                                                                                                                                                                                                                                                                                                                                        type UnaryCall = (
                                                                                                                                                                                                                                                                                                                                                                                                                        argument: {},
                                                                                                                                                                                                                                                                                                                                                                                                                        metadata: {},
                                                                                                                                                                                                                                                                                                                                                                                                                        options: {},
                                                                                                                                                                                                                                                                                                                                                                                                                        callback: APICallback
                                                                                                                                                                                                                                                                                                                                                                                                                        ) => GRPCCallResult;

                                                                                                                                                                                                                                                                                                                                                                                                                          Namespaces

                                                                                                                                                                                                                                                                                                                                                                                                                          namespace fallback

                                                                                                                                                                                                                                                                                                                                                                                                                          module 'build/src/fallback.d.ts' {}
                                                                                                                                                                                                                                                                                                                                                                                                                          • Copyright 2020 Google LLC

                                                                                                                                                                                                                                                                                                                                                                                                                            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.

                                                                                                                                                                                                                                                                                                                                                                                                                          variable defaultToObjectOptions

                                                                                                                                                                                                                                                                                                                                                                                                                          const defaultToObjectOptions: {
                                                                                                                                                                                                                                                                                                                                                                                                                          keepCase: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                          longs: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                                                                          enums: StringConstructor;
                                                                                                                                                                                                                                                                                                                                                                                                                          defaults: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                          oneofs: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                            variable fallback

                                                                                                                                                                                                                                                                                                                                                                                                                            const fallback: any;

                                                                                                                                                                                                                                                                                                                                                                                                                              variable version

                                                                                                                                                                                                                                                                                                                                                                                                                              const version: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                function constructSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                constructSettings: (
                                                                                                                                                                                                                                                                                                                                                                                                                                serviceName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                clientConfig: ClientConfig,
                                                                                                                                                                                                                                                                                                                                                                                                                                configOverrides: ClientConfig,
                                                                                                                                                                                                                                                                                                                                                                                                                                retryNames: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                otherArgs?: {}
                                                                                                                                                                                                                                                                                                                                                                                                                                ) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                • Constructs a dictionary mapping method names to CallSettings.

                                                                                                                                                                                                                                                                                                                                                                                                                                  The clientConfig parameter is parsed from a client configuration JSON file of the form:

                                                                                                                                                                                                                                                                                                                                                                                                                                  { "interfaces": { "google.fake.v1.ServiceName": { "retry_codes": { "idempotent": ["UNAVAILABLE", "DEADLINE_EXCEEDED"], "non_idempotent": [] }, "retry_params": { "default": { "initial_retry_delay_millis": 100, "retry_delay_multiplier": 1.2, "max_retry_delay_millis": 1000, "initial_rpc_timeout_millis": 2000, "rpc_timeout_multiplier": 1.5, "max_rpc_timeout_millis": 30000, "total_timeout_millis": 45000 } }, "methods": { "CreateFoo": { "retry_codes_name": "idempotent", "retry_params_name": "default" }, "Publish": { "retry_codes_name": "non_idempotent", "retry_params_name": "default", "bundling": { "element_count_threshold": 40, "element_count_limit": 200, "request_byte_threshold": 90000, "request_byte_limit": 100000, "delay_threshold_millis": 100 } } } } } }

                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter serviceName

                                                                                                                                                                                                                                                                                                                                                                                                                                  The fully-qualified name of this service, used as a key into the client config file (in the example above, this value should be 'google.fake.v1.ServiceName').

                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter clientConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                  A dictionary parsed from the standard API client config file.

                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter configOverrides

                                                                                                                                                                                                                                                                                                                                                                                                                                  A dictionary in the same structure of client_config to override the settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter retryNames

                                                                                                                                                                                                                                                                                                                                                                                                                                  A dictionary mapping the strings referring to response status codes to objects representing those codes.

                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter otherArgs

                                                                                                                                                                                                                                                                                                                                                                                                                                  the non-request arguments to be passed to the API calls. {Object} A mapping from method name to CallSettings, or null if the service is not found in the config.

                                                                                                                                                                                                                                                                                                                                                                                                                                function createApiCall

                                                                                                                                                                                                                                                                                                                                                                                                                                createApiCall: (
                                                                                                                                                                                                                                                                                                                                                                                                                                func: Promise<GRPCCall> | GRPCCall,
                                                                                                                                                                                                                                                                                                                                                                                                                                settings: gax.CallSettings,
                                                                                                                                                                                                                                                                                                                                                                                                                                descriptor?: Descriptor
                                                                                                                                                                                                                                                                                                                                                                                                                                ) => GaxCall;
                                                                                                                                                                                                                                                                                                                                                                                                                                • gRPC-fallback version of createApiCall

                                                                                                                                                                                                                                                                                                                                                                                                                                  Converts an rpc call into an API call governed by the settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                  In typical usage, func will be a promise to a callable used to make an rpc request. This will mostly likely be a bound method from a request stub used to make an rpc call. It is not a direct function but a Promise instance, because of its asynchronism (typically, obtaining the auth information).

                                                                                                                                                                                                                                                                                                                                                                                                                                  The result is a function which manages the API call with the given settings and the options on the invocation.

                                                                                                                                                                                                                                                                                                                                                                                                                                  Throws exception on unsupported streaming calls

                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter func

                                                                                                                                                                                                                                                                                                                                                                                                                                  is either a promise to be used to make a bare RPC call, or just a bare RPC call.

                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter settings

                                                                                                                                                                                                                                                                                                                                                                                                                                  provides the settings for this call

                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter descriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                  optionally specify the descriptor for the method call. {GaxCall} func - a bound method on a request stub used to make an rpc call.

                                                                                                                                                                                                                                                                                                                                                                                                                                function lro

                                                                                                                                                                                                                                                                                                                                                                                                                                lro: (options: GrpcClientOptions) => OperationsClientBuilder;
                                                                                                                                                                                                                                                                                                                                                                                                                                • gRPC-fallback version of lro

                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                                                                                                                                                                                                                  {Object=} options.auth - An instance of google-auth-library. {Object} A OperationsClientBuilder that will return a OperationsClient

                                                                                                                                                                                                                                                                                                                                                                                                                                class BundleDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                class BundleDescriptor implements Descriptor {}
                                                                                                                                                                                                                                                                                                                                                                                                                                • A descriptor for calls that can be bundled into one call.

                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                bundledField: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                requestDiscriminatorFields: string[],
                                                                                                                                                                                                                                                                                                                                                                                                                                subresponseField: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                byteLengthFunction: Function
                                                                                                                                                                                                                                                                                                                                                                                                                                );
                                                                                                                                                                                                                                                                                                                                                                                                                                • Describes the structure of bundled call.

                                                                                                                                                                                                                                                                                                                                                                                                                                  requestDiscriminatorFields may include '.' as a separator, which is used to indicate object traversal. This allows fields in nested objects to be used to determine what request to bundle.

                                                                                                                                                                                                                                                                                                                                                                                                                                  {String} bundledField {String} requestDiscriminatorFields {String} subresponseField {Function} byteLengthFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter bundledField

                                                                                                                                                                                                                                                                                                                                                                                                                                  the repeated field in the request message that will have its elements aggregated by bundling.

                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter requestDiscriminatorFields

                                                                                                                                                                                                                                                                                                                                                                                                                                  a list of fields in the target request message class that are used to detemrine which request messages should be bundled together.

                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter subresponseField

                                                                                                                                                                                                                                                                                                                                                                                                                                  an optional field, when present it indicates the field in the response message that should be used to demultiplex the response into multiple response messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter byteLengthFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                  a function to obtain the byte length to be consumed for the bundled field messages. Because Node.JS protobuf.js/gRPC uses builtin Objects for the user-visible data and internally they are encoded/decoded in protobuf manner, this function is actually necessary to calculate the byte length.

                                                                                                                                                                                                                                                                                                                                                                                                                                property bundledField

                                                                                                                                                                                                                                                                                                                                                                                                                                bundledField: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property byteLengthFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                  byteLengthFunction: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property requestDiscriminatorFields

                                                                                                                                                                                                                                                                                                                                                                                                                                    requestDiscriminatorFields: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                      property subresponseField

                                                                                                                                                                                                                                                                                                                                                                                                                                      subresponseField: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method getApiCaller

                                                                                                                                                                                                                                                                                                                                                                                                                                        getApiCaller: (settings: CallSettings) => NormalApiCaller | BundleApiCaller;

                                                                                                                                                                                                                                                                                                                                                                                                                                          class CallSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                          class CallSettings {}

                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(settings?: CallOptions);
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Parameter settings

                                                                                                                                                                                                                                                                                                                                                                                                                                              An object containing parameters of this settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter

                                                                                                                                                                                                                                                                                                                                                                                                                                              {number} settings.timeout - The client-side timeout for API calls. This parameter is ignored for retrying calls.

                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter

                                                                                                                                                                                                                                                                                                                                                                                                                                              {RetryOptions} settings.retry - The configuration for retrying upon transient error. If set to null, this call will not retry.

                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter

                                                                                                                                                                                                                                                                                                                                                                                                                                              {boolean} settings.autoPaginate - If there is no pageDescriptor, this attrbute has no meaning. Otherwise, determines whether a page streamed response should make the page structure transparent to the user by flattening the repeated field in the returned generator.

                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter

                                                                                                                                                                                                                                                                                                                                                                                                                                              {number} settings.pageToken - If there is no pageDescriptor, this attribute has no meaning. Otherwise, determines the page token used in the page streaming request.

                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter

                                                                                                                                                                                                                                                                                                                                                                                                                                              {Object} settings.otherArgs - Additional arguments to be passed to the API calls.

                                                                                                                                                                                                                                                                                                                                                                                                                                            property apiName

                                                                                                                                                                                                                                                                                                                                                                                                                                            apiName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property autoPaginate

                                                                                                                                                                                                                                                                                                                                                                                                                                              autoPaginate?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property bundleOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                bundleOptions?: BundleOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property isBundling

                                                                                                                                                                                                                                                                                                                                                                                                                                                  isBundling: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property longrunning

                                                                                                                                                                                                                                                                                                                                                                                                                                                    longrunning?: BackoffSettings;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property maxResults

                                                                                                                                                                                                                                                                                                                                                                                                                                                      maxResults?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property otherArgs

                                                                                                                                                                                                                                                                                                                                                                                                                                                        otherArgs: { [index: string]: any };

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property pageSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                          pageSize?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property pageToken

                                                                                                                                                                                                                                                                                                                                                                                                                                                            pageToken?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property retry

                                                                                                                                                                                                                                                                                                                                                                                                                                                              retry?: RetryOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property retryRequestOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                retryRequestOptions?: RetryRequestOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  timeout: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method merge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    merge: (options?: CallOptions | null) => CallSettings;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Returns a new CallSettings merged from this and a CallOptions object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      an instance whose values override those in this object. If null, ``merge`` returns a copy of this object {CallSettings} The merged CallSettings instance.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class GrpcClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class GrpcClient {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: (GrpcClientOptions | { auth: any }) & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fallback?: boolean | 'rest' | 'proto';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      );
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • gRPC-fallback version of GrpcClient Implements GrpcClient API for a browser using grpc-fallback protocol (sends serialized protobuf to HTTP/1 $rpc endpoint).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        {Object=} options.auth - An instance of OAuth2Client to use in browser, or an instance of GoogleAuth from google-auth-library to use in Node.js. Required for browser, optional for Node.js.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property auth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      auth?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property authClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        authClient?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property fallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fallback: boolean | 'rest' | 'proto';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property grpcVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            grpcVersion: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method clearProtoCache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static clearProtoCache: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • In rare cases users might need to deallocate all memory consumed by loaded protos. This method will delete the proto cache content.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method constructSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructSettings: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              serviceName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              clientConfig: gax.ClientConfig,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              configOverrides: gax.ClientConfig,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              headers: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gRPC-fallback version of constructSettings A wrapper of constructSettings function under the gRPC context.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Most of parameters are common among constructSettings, please take a look.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter serviceName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The fullly-qualified name of the service.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter clientConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                A dictionary of the client config.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter configOverrides

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                A dictionary of overriding configs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter headers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                A dictionary of additional HTTP header name to its value. {Object} A mapping of method names to CallSettings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method createStub

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              createStub: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              service: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts: ClientStubOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              customServicePath?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<import('./fallbackServiceStub').FallbackServiceStub>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gRPC-fallback version of createStub Creates a gRPC-fallback stub with authentication headers built from supplied OAuth2Client instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter CreateStub

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The constructor function of the stub.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter service

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                A protobufjs Service object (as returned by lookupService)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter opts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Connection options, as described below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {string} opts.servicePath - The hostname of the API endpoint service.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {number} opts.port - The port of the service. {Promise} A promise which resolves to a gRPC-fallback service stub, which is a protobuf.js service stub instance modified to match the gRPC stub API

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method loadProto

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              loadProto: (jsonObject: {}) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • gRPC-fallback version of loadProto Loads the protobuf root object from a JSON object created from a proto file

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter jsonObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                A JSON version of a protofile created usin protobuf.js

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {Object} Root namespace of proto JSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method loadProtoJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              loadProtoJSON: (json: any, ignoreCache?: boolean) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class LongrunningDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class LongRunningDescriptor implements Descriptor {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • A descriptor for long-running operations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                operationsClient: OperationsClient,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                responseDecoder: AnyDecoder,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                metadataDecoder: AnyDecoder
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property metadataDecoder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  metadataDecoder: AnyDecoder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property operationsClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    operationsClient: OperationsClient;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property responseDecoder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      responseDecoder: AnyDecoder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getApiCaller

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getApiCaller: () => LongrunningApiCaller;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class PageDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class PageDescriptor implements Descriptor {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • A descriptor for methods that support pagination.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          requestPageTokenField: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          responsePageTokenField: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resourceField: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property requestPageSizeField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            requestPageSizeField?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property requestPageTokenField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              requestPageTokenField: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property resourceField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                resourceField: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property responsePageTokenField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  responsePageTokenField: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method asyncIterate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    asyncIterate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    apiCall: GaxCall,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    request: RequestType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: CallSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => AsyncIterable<{} | undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Create an async iterable which can be recursively called for data on-demand.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method createIterator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    createIterator: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    apiCall: GaxCall,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    request: RequestType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options: CallSettings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => AsyncIterable<{} | undefined>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method createStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createStream: (apiCall: GaxCall, request: {}, options: CallSettings) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Creates a new object Stream which emits the resource on 'data' event.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getApiCaller

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getApiCaller: (settings: CallSettings) => APICaller;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class PathTemplate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class PathTemplate {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(data: string);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameter data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            the of the template

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property segments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          segments: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            size: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method inspect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              inspect: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Renders the path template.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {string} contains const names matched to binding values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method match

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              match: (path: string) => Bindings;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Matches a fully-qualified path template string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                a fully-qualified path template string {Object} contains const names matched to binding values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Throws

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {TypeError} if path can't be matched to this template

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              render: (bindings: Bindings) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Renders a path template using the provided bindings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter bindings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                a mapping of const names to binding strings {String} a rendered representation of the path template

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Throws

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {TypeError} if a key is missing, or if a sub-template cannot be parsed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class RetryOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class RetryOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Per-call configurable settings for retrying upon transient failure. {Object} RetryOptions {String[]} retryCodes {BackoffSettings} backoffSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(retryCodes: number[], backoffSettings: BackoffSettings);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property backoffSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                backoffSettings: BackoffSettings;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property retryCodes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  retryCodes: number[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class StreamDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class StreamDescriptor implements Descriptor {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • A descriptor for streaming calls.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(streamType: StreamType);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property streaming

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      streaming: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: StreamType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getApiCaller

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getApiCaller: (settings: CallSettings) => APICaller;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ServiceMethods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ServiceMethods {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [name: string]: protobuf.Method;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enum StreamType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enum StreamType {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SERVER_STREAMING = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                CLIENT_STREAMING = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                BIDI_STREAMING = 3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • The type of gRPC streaming. {number}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member BIDI_STREAMING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                BIDI_STREAMING = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Both client and server stream objects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member CLIENT_STREAMING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                CLIENT_STREAMING = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Client streams requests, server returns a single response.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member SERVER_STREAMING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SERVER_STREAMING = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Client sends a single request, server streams responses.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type AuthClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type AuthClient =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | OAuth2Client
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Compute
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | JWT
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | UserRefreshClient
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | BaseExternalAccountClient;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FallbackServiceError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FallbackServiceError = FallbackStatusObject & Error;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace routingHeader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    module 'build/src/routingHeader.d.ts' {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Copyright 2020 Google LLC

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function fromParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fromParams: (params: { [index: string]: string | number | boolean }) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Constructs the routing header from the given params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      the request header parameters. {string} the routing header value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace IamProtos

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    module 'build/protos/iam_service.d.ts' {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Copyright 2021 Google LLC

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace IamProtos.google

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace IamProtos.google {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Namespace google.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace IamProtos.google.api

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace IamProtos.google.api {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Namespace api.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class CustomHttpPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class CustomHttpPattern implements ICustomHttpPattern {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Represents a CustomHttpPattern.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(properties?: ICustomHttpPattern);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Constructs a new CustomHttpPattern.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Properties to set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    kind: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • CustomHttpPattern kind.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    path: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • CustomHttpPattern path.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static create: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    properties?: google.api.ICustomHttpPattern
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => google.api.CustomHttpPattern;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Creates a new CustomHttpPattern instance using the specified properties.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Properties to set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CustomHttpPattern instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method decode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static decode: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reader: $protobuf.Reader | Uint8Array,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    length?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => google.api.CustomHttpPattern;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Decodes a CustomHttpPattern message from the specified reader or buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter reader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter length

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Message length if known beforehand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CustomHttpPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Throws

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Throws

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method decodeDelimited

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static decodeDelimited: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reader: $protobuf.Reader | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => google.api.CustomHttpPattern;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Decodes a CustomHttpPattern message from the specified reader or buffer, length delimited.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter reader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CustomHttpPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Throws

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Throws

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static encode: (message: google.api.ICustomHttpPattern, writer?: any) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Encodes the specified CustomHttpPattern message. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CustomHttpPattern message or plain object to encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter writer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Writer to encode to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Writer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method encodeDelimited

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static encodeDelimited: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    message: google.api.ICustomHttpPattern,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    writer?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Encodes the specified CustomHttpPattern message, length delimited. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CustomHttpPattern message or plain object to encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter writer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Writer to encode to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Writer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method fromObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static fromObject: (object: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [k: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }) => google.api.CustomHttpPattern;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Creates a CustomHttpPattern message from a plain object. Also converts values to their respective internal types.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Plain object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CustomHttpPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method toJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toJSON: () => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Converts this CustomHttpPattern to JSON.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      JSON object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method toObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static toObject: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    message: google.api.CustomHttpPattern,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Creates a plain object from a CustomHttpPattern message. Also converts values to other types if specified.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CustomHttpPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Conversion options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Plain object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static verify: (message: { [k: string]: any }) => string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Verifies a CustomHttpPattern message.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Plain object to verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      null if valid, otherwise the reason why it is not

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Http

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Http implements IHttp {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Represents a Http.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(properties?: IHttp);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Constructs a new Http.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Properties to set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property fullyDecodeReservedExpansion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fullyDecodeReservedExpansion: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Http fullyDecodeReservedExpansion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property rules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rules: IHttpRule[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Http rules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static create: (properties?: google.api.IHttp) => google.api.Http;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Creates a new Http instance using the specified properties.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Properties to set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Http instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method decode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static decode: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reader: $protobuf.Reader | Uint8Array,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    length?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => google.api.Http;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Decodes a Http message from the specified reader or buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter reader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter length

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Message length if known beforehand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Http

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Throws

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Throws

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method decodeDelimited

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static decodeDelimited: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reader: $protobuf.Reader | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => google.api.Http;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Decodes a Http message from the specified reader or buffer, length delimited.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter reader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Http

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Throws

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Throws

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static encode: (message: google.api.IHttp, writer?: any) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Encodes the specified Http message. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Http message or plain object to encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter writer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Writer to encode to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Writer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method encodeDelimited

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static encodeDelimited: (message: google.api.IHttp, writer?: any) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Encodes the specified Http message, length delimited. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Http message or plain object to encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter writer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Writer to encode to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Writer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method fromObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static fromObject: (object: { [k: string]: any }) => google.api.Http;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Creates a Http message from a plain object. Also converts values to their respective internal types.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Plain object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Http

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method toJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toJSON: () => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Converts this Http to JSON.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      JSON object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method toObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static toObject: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    message: google.api.Http,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Creates a plain object from a Http message. Also converts values to other types if specified.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Http

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Conversion options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Plain object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static verify: (message: { [k: string]: any }) => string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Verifies a Http message.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Plain object to verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      null if valid, otherwise the reason why it is not

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class HttpRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class HttpRule implements IHttpRule {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Represents a HttpRule.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(properties?: IHttpRule);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Constructs a new HttpRule.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Properties to set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property additionalBindings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    additionalBindings: IHttpRule[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • HttpRule additionalBindings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property body

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    body: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • HttpRule body.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property custom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    custom?: ICustomHttpPattern;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • HttpRule custom.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property delete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    delete: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • HttpRule delete.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    get: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • HttpRule get.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property patch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    patch: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • HttpRule patch.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property pattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pattern?: 'get' | 'put' | 'post' | 'delete' | 'patch' | 'custom';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • HttpRule pattern.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property post

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    post: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • HttpRule post.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property put

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    put: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • HttpRule put.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property responseBody

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    responseBody: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • HttpRule responseBody.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    selector: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • HttpRule selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static create: (properties?: google.api.IHttpRule) => google.api.HttpRule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Creates a new HttpRule instance using the specified properties.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Properties to set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HttpRule instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method decode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static decode: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reader: $protobuf.Reader | Uint8Array,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    length?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => google.api.HttpRule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Decodes a HttpRule message from the specified reader or buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter reader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter length

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Message length if known beforehand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HttpRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Throws

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Throws

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method decodeDelimited

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static decodeDelimited: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reader: $protobuf.Reader | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => google.api.HttpRule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Decodes a HttpRule message from the specified reader or buffer, length delimited.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter reader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HttpRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Throws

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Throws

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static encode: (message: google.api.IHttpRule, writer?: any) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Encodes the specified HttpRule message. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HttpRule message or plain object to encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter writer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Writer to encode to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Writer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method encodeDelimited

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static encodeDelimited: (message: google.api.IHttpRule, writer?: any) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Encodes the specified HttpRule message, length delimited. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HttpRule message or plain object to encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter writer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Writer to encode to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Writer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method fromObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static fromObject: (object: { [k: string]: any }) => google.api.HttpRule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Creates a HttpRule message from a plain object. Also converts values to their respective internal types.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Plain object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HttpRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method toJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toJSON: () => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Converts this HttpRule to JSON.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      JSON object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method toObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static toObject: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    message: google.api.HttpRule,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => { [k: string]: any };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Creates a plain object from a HttpRule message. Also converts values to other types if specified.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HttpRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Conversion options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Plain object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static verify: (message: { [k: string]: any }) => string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Verifies a HttpRule message.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Plain object to verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      null if valid, otherwise the reason why it is not

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ResourceDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ResourceDescriptor implements IResourceDescriptor {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Represents a ResourceDescriptor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(properties?: IResourceDescriptor);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Constructs a new ResourceDescriptor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Properties to set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property history

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    history: ResourceDescriptor.History;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ResourceDescriptor history.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property nameField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nameField: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ResourceDescriptor nameField.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property pattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pattern: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ResourceDescriptor pattern.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property plural

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    plural: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ResourceDescriptor plural.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property singular

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    singular: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ResourceDescriptor singular.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ResourceDescriptor type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static create: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    properties?: google.api.IResourceDescriptor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => google.api.ResourceDescriptor;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Creates a new ResourceDescriptor instance using the specified properties.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Properties to set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ResourceDescriptor instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method decode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static decode: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reader: $protobuf.Reader | Uint8Array,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    length?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => google.api.ResourceDescriptor;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Decodes a ResourceDescriptor message from the specified reader or buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter reader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter length

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Message length if known beforehand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ResourceDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Throws

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Throws

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method decodeDelimited

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static decodeDelimited: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reader: $protobuf.Reader | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => google.api.ResourceDescriptor;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Decodes a ResourceDescriptor message from the specified reader or buffer, length delimited.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter reader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Reader or buffer to decode from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ResourceDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Throws

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {Error} If the payload is not a reader or valid buffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Throws

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {$protobuf.util.ProtocolError} If required fields are missing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static encode: (message: google.api.IResourceDescriptor, writer?: any) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Encodes the specified ResourceDescriptor message. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ResourceDescriptor message or plain object to encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter writer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Writer to encode to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Writer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method encodeDelimited

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static encodeDelimited: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    message: google.api.IResourceDescriptor,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    writer?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Encodes the specified ResourceDescriptor message, length delimited. Does not implicitly verify messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ResourceDescriptor message or plain object to encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter writer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Writer to encode to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Writer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method fromObject