@grpc/grpc-js

  • Version 1.3.2
  • Published
  • 967 kB
  • 1 dependency
  • Apache-2.0 license

Install

npm i @grpc/grpc-js
yarn add @grpc/grpc-js
pnpm add @grpc/grpc-js

Overview

gRPC Library for Node - pure JS implementation

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable credentials

const credentials: {
combineChannelCredentials: (
channelCredentials: ChannelCredentials,
...callCredentials: CallCredentials[]
) => ChannelCredentials;
combineCallCredentials: (
first: CallCredentials,
...additional: CallCredentials[]
) => CallCredentials;
createInsecure: typeof ChannelCredentials.createInsecure;
createSsl: typeof ChannelCredentials.createSsl;
createFromMetadataGenerator: typeof CallCredentials.createFromMetadataGenerator;
createFromGoogleCredential: typeof CallCredentials.createFromGoogleCredential;
createEmpty: typeof CallCredentials.createEmpty;
};
  • ** Client Credentials ***

Functions

function closeClient

closeClient: (client: Client) => void;
  • Close a Client object.

    Parameter client

    The client to close.

function getClientChannel

getClientChannel: (client: Client) => Channel;

    function load

    load: (filename: any, format: any, options: any) => never;

      function loadObject

      loadObject: (value: any, options: any) => never;
      • ** Unimplemented function stubs ***

      function loadPackageDefinition

      loadPackageDefinition: (packageDef: PackageDefinition) => GrpcObject;
      • Load a gRPC package definition as a gRPC object hierarchy.

        Parameter packageDef

        The package definition object. The resulting gRPC object.

      function makeClientConstructor

      makeClientConstructor: (
      methods: ServiceDefinition,
      serviceName: string,
      classOptions?: {}
      ) => ServiceClientConstructor;
      • Creates a constructor for a client with the given methods, as specified in the methods argument. The resulting class will have an instance method for each method in the service, which is a partial application of one of the [Client]grpc.Client request methods, depending on requestSerialize and responseSerialize, with the method, serialize, and deserialize arguments predefined.

        Parameter methods

        An object mapping method names to method attributes

        Parameter serviceName

        The fully qualified name of the service

        Parameter classOptions

        An options object. New client constructor, which is a subclass of grpc.Client, and has the same arguments as that constructor.

      function makeGenericClientConstructor

      makeGenericClientConstructor: (
      methods: ServiceDefinition,
      serviceName: string,
      classOptions?: {}
      ) => ServiceClientConstructor;
      • Creates a constructor for a client with the given methods, as specified in the methods argument. The resulting class will have an instance method for each method in the service, which is a partial application of one of the [Client]grpc.Client request methods, depending on requestSerialize and responseSerialize, with the method, serialize, and deserialize arguments predefined.

        Parameter methods

        An object mapping method names to method attributes

        Parameter serviceName

        The fully qualified name of the service

        Parameter classOptions

        An options object. New client constructor, which is a subclass of grpc.Client, and has the same arguments as that constructor.

      function setLogger

      setLogger: (logger: Partial<Console>) => void;

        function setLogVerbosity

        setLogVerbosity: (verbosity: LogVerbosity) => void;

          function waitForClientReady

          waitForClientReady: (
          client: Client,
          deadline: Date | number,
          callback: (error?: Error | undefined) => void
          ) => void;

            Classes

            class CallCredentials

            abstract class CallCredentials {}
            • A class that represents a generic method of adding authentication-related metadata on a per-request basis.

            method compose

            abstract compose: (callCredentials: CallCredentials) => CallCredentials;
            • Creates a new CallCredentials object from properties of both this and another CallCredentials object. This object's metadata generator will be called first.

              Parameter callCredentials

              The other CallCredentials object.

            method createEmpty

            static createEmpty: () => CallCredentials;

              method createFromGoogleCredential

              static createFromGoogleCredential: (
              googleCredentials: OAuth2Client
              ) => CallCredentials;
              • Create a gRPC credential from a Google credential object.

                Parameter googleCredentials

                The authentication client to use. The resulting CallCredentials object.

              method createFromMetadataGenerator

              static createFromMetadataGenerator: (
              metadataGenerator: CallMetadataGenerator
              ) => CallCredentials;
              • Creates a new CallCredentials object from a given function that generates Metadata objects.

                Parameter metadataGenerator

                A function that accepts a set of options, and generates a Metadata object based on these options, which is passed back to the caller via a supplied (err, metadata) callback.

              method generateMetadata

              abstract generateMetadata: (options: CallMetadataOptions) => Promise<Metadata>;
              • Asynchronously generates a new Metadata object.

                Parameter options

                Options used in generating the Metadata object.

              class Channel

              class ChannelImplementation implements Channel {}

                constructor

                constructor(
                target: string,
                credentials: ChannelCredentials,
                options: ChannelOptions
                );

                  method close

                  close: () => void;

                    method createCall

                    createCall: (
                    method: string,
                    deadline: Deadline,
                    host: string | null | undefined,
                    parentCall: ServerSurfaceCall | null,
                    propagateFlags: number | null | undefined
                    ) => Call;

                      method getConnectivityState

                      getConnectivityState: (tryToConnect: boolean) => ConnectivityState;

                        method getTarget

                        getTarget: () => string;

                          method watchConnectivityState

                          watchConnectivityState: (
                          currentState: ConnectivityState,
                          deadline: Date | number,
                          callback: (error?: Error) => void
                          ) => void;

                            class ChannelCredentials

                            abstract class ChannelCredentials {}
                            • A class that contains credentials for communicating over a channel, as well as a set of per-call credentials, which are applied to every method call made over a channel initialized with an instance of this class.

                            constructor

                            protected constructor(callCredentials?: CallCredentials);

                              property callCredentials

                              protected callCredentials: CallCredentials;

                                method compose

                                abstract compose: (callCredentials: CallCredentials) => ChannelCredentials;
                                • Returns a copy of this object with the included set of per-call credentials expanded to include callCredentials.

                                  Parameter callCredentials

                                  A CallCredentials object to associate with this instance.

                                method createInsecure

                                static createInsecure: () => ChannelCredentials;
                                • Return a new ChannelCredentials instance with no credentials.

                                method createSsl

                                static createSsl: (
                                rootCerts?: Buffer | null,
                                privateKey?: Buffer | null,
                                certChain?: Buffer | null,
                                verifyOptions?: VerifyOptions
                                ) => ChannelCredentials;
                                • Return a new ChannelCredentials instance with a given set of credentials. The resulting instance can be used to construct a Channel that communicates over TLS.

                                  Parameter rootCerts

                                  The root certificate data.

                                  Parameter privateKey

                                  The client certificate private key, if available.

                                  Parameter certChain

                                  The client certificate key chain, if available.

                                class Client

                                class Client {}
                                • A generic gRPC client. Primarily useful as a base class for all generated clients.

                                constructor

                                constructor(
                                address: string,
                                credentials: ChannelCredentials,
                                options?: ClientOptions
                                );

                                  method close

                                  close: () => void;

                                    method getChannel

                                    getChannel: () => Channel;

                                      method makeBidiStreamRequest

                                      makeBidiStreamRequest: {
                                      <RequestType, ResponseType>(
                                      method: string,
                                      serialize: (value: RequestType) => any,
                                      deserialize: (value: any) => ResponseType,
                                      metadata: Metadata,
                                      options?: CallOptions
                                      ): ClientDuplexStream<RequestType, ResponseType>;
                                      <RequestType, ResponseType>(
                                      method: string,
                                      serialize: (value: RequestType) => any,
                                      deserialize: (value: any) => ResponseType,
                                      options?: CallOptions
                                      ): any;
                                      };

                                        method makeClientStreamRequest

                                        makeClientStreamRequest: {
                                        <RequestType, ResponseType>(
                                        method: string,
                                        serialize: (value: RequestType) => any,
                                        deserialize: (value: any) => ResponseType,
                                        metadata: Metadata,
                                        options: CallOptions,
                                        callback: UnaryCallback<ResponseType>
                                        ): ClientWritableStream<RequestType>;
                                        <RequestType, ResponseType>(
                                        method: string,
                                        serialize: (value: RequestType) => any,
                                        deserialize: (value: any) => ResponseType,
                                        metadata: Metadata,
                                        callback: UnaryCallback<ResponseType>
                                        ): any;
                                        <RequestType, ResponseType>(
                                        method: string,
                                        serialize: (value: RequestType) => any,
                                        deserialize: (value: any) => ResponseType,
                                        options: CallOptions,
                                        callback: UnaryCallback<ResponseType>
                                        ): any;
                                        <RequestType, ResponseType>(
                                        method: string,
                                        serialize: (value: RequestType) => any,
                                        deserialize: (value: any) => ResponseType,
                                        callback: UnaryCallback<ResponseType>
                                        ): any;
                                        };

                                          method makeServerStreamRequest

                                          makeServerStreamRequest: {
                                          <RequestType, ResponseType>(
                                          method: string,
                                          serialize: (value: RequestType) => any,
                                          deserialize: (value: any) => ResponseType,
                                          argument: RequestType,
                                          metadata: Metadata,
                                          options?: CallOptions
                                          ): ClientReadableStream<ResponseType>;
                                          <RequestType, ResponseType>(
                                          method: string,
                                          serialize: (value: RequestType) => any,
                                          deserialize: (value: any) => ResponseType,
                                          argument: RequestType,
                                          options?: CallOptions
                                          ): any;
                                          };

                                            method makeUnaryRequest

                                            makeUnaryRequest: {
                                            <RequestType, ResponseType>(
                                            method: string,
                                            serialize: (value: RequestType) => any,
                                            deserialize: (value: any) => ResponseType,
                                            argument: RequestType,
                                            metadata: Metadata,
                                            options: CallOptions,
                                            callback: UnaryCallback<ResponseType>
                                            ): ClientUnaryCall;
                                            <RequestType, ResponseType>(
                                            method: string,
                                            serialize: (value: RequestType) => any,
                                            deserialize: (value: any) => ResponseType,
                                            argument: RequestType,
                                            metadata: Metadata,
                                            callback: UnaryCallback<ResponseType>
                                            ): any;
                                            <RequestType, ResponseType>(
                                            method: string,
                                            serialize: (value: RequestType) => any,
                                            deserialize: (value: any) => ResponseType,
                                            argument: RequestType,
                                            options: CallOptions,
                                            callback: UnaryCallback<ResponseType>
                                            ): any;
                                            <RequestType, ResponseType>(
                                            method: string,
                                            serialize: (value: RequestType) => any,
                                            deserialize: (value: any) => ResponseType,
                                            argument: RequestType,
                                            callback: UnaryCallback<ResponseType>
                                            ): any;
                                            };

                                              method waitForReady

                                              waitForReady: (deadline: Deadline, callback: (error?: Error) => void) => void;

                                                class InterceptingCall

                                                class InterceptingCall implements InterceptingCallInterface {}

                                                  constructor

                                                  constructor(
                                                  nextCall: InterceptingCallInterface,
                                                  requester?: Partial<FullRequester>
                                                  );

                                                    method cancelWithStatus

                                                    cancelWithStatus: (status: Status, details: string) => void;

                                                      method getPeer

                                                      getPeer: () => string;

                                                        method halfClose

                                                        halfClose: () => void;

                                                          method sendMessage

                                                          sendMessage: (message: any) => void;

                                                            method sendMessageWithContext

                                                            sendMessageWithContext: (context: MessageContext, message: any) => void;

                                                              method setCredentials

                                                              setCredentials: (credentials: CallCredentials) => void;

                                                                method start

                                                                start: (
                                                                metadata: Metadata,
                                                                interceptingListener?: Partial<InterceptingListener>
                                                                ) => void;

                                                                  method startRead

                                                                  startRead: () => void;

                                                                    class InterceptorConfigurationError

                                                                    class InterceptorConfigurationError extends Error {}
                                                                    • Error class associated with passing both interceptors and interceptor providers to a client constructor or as call options.

                                                                    constructor

                                                                    constructor(message: string);

                                                                      class ListenerBuilder

                                                                      class ListenerBuilder {}

                                                                        method build

                                                                        build: () => Listener;

                                                                          method withOnReceiveMessage

                                                                          withOnReceiveMessage: (onReceiveMessage: MessageListener) => this;

                                                                            method withOnReceiveMetadata

                                                                            withOnReceiveMetadata: (onReceiveMetadata: MetadataListener) => this;

                                                                              method withOnReceiveStatus

                                                                              withOnReceiveStatus: (onReceiveStatus: StatusListener) => this;

                                                                                class Metadata

                                                                                class Metadata {}
                                                                                • A class for storing metadata. Keys are normalized to lowercase ASCII.

                                                                                constructor

                                                                                constructor(options?: MetadataOptions);

                                                                                  property internalRepr

                                                                                  protected internalRepr: MetadataObject;

                                                                                    method add

                                                                                    add: (key: string, value: MetadataValue) => void;
                                                                                    • Adds the given value for the given key by appending to a list of previous values associated with that key. Normalizes the key.

                                                                                      Parameter key

                                                                                      The key for which a new value should be appended.

                                                                                      Parameter value

                                                                                      The value to add. Must be a buffer if and only if the normalized key ends with '-bin'.

                                                                                    method clone

                                                                                    clone: () => Metadata;
                                                                                    • Clones the metadata object. The newly cloned object.

                                                                                    method fromHttp2Headers

                                                                                    static fromHttp2Headers: (headers: any) => Metadata;
                                                                                    • Returns a new Metadata object based fields in a given IncomingHttpHeaders object.

                                                                                      Parameter headers

                                                                                      An IncomingHttpHeaders object.

                                                                                    method get

                                                                                    get: (key: string) => MetadataValue[];
                                                                                    • Gets a list of all values associated with the key. Normalizes the key.

                                                                                      Parameter key

                                                                                      The key whose value should be retrieved. A list of values associated with the given key.

                                                                                    method getMap

                                                                                    getMap: () => { [key: string]: any };
                                                                                    • Gets a plain object mapping each key to the first value associated with it. This reflects the most common way that people will want to see metadata. A key/value mapping of the metadata.

                                                                                    method getOptions

                                                                                    getOptions: () => MetadataOptions;

                                                                                      method merge

                                                                                      merge: (other: Metadata) => void;
                                                                                      • Merges all key-value pairs from a given Metadata object into this one. If both this object and the given object have values in the same key, values from the other Metadata object will be appended to this object's values.

                                                                                        Parameter other

                                                                                        A Metadata object.

                                                                                      method remove

                                                                                      remove: (key: string) => void;
                                                                                      • Removes the given key and any associated values. Normalizes the key.

                                                                                        Parameter key

                                                                                        The key whose values should be removed.

                                                                                      method set

                                                                                      set: (key: string, value: MetadataValue) => void;
                                                                                      • Sets the given value for the given key by replacing any other values associated with that key. Normalizes the key.

                                                                                        Parameter key

                                                                                        The key to whose value should be set.

                                                                                        Parameter value

                                                                                        The value to set. Must be a buffer if and only if the normalized key ends with '-bin'.

                                                                                      method setOptions

                                                                                      setOptions: (options: MetadataOptions) => void;

                                                                                        method toHttp2Headers

                                                                                        toHttp2Headers: () => any;
                                                                                        • Creates an OutgoingHttpHeaders object that can be used with the http2 API.

                                                                                        class RequesterBuilder

                                                                                        class RequesterBuilder {}

                                                                                          method build

                                                                                          build: () => Requester;

                                                                                            method withCancel

                                                                                            withCancel: (cancel: CancelRequester) => this;

                                                                                              method withHalfClose

                                                                                              withHalfClose: (halfClose: CloseRequester) => this;

                                                                                                method withSendMessage

                                                                                                withSendMessage: (sendMessage: MessageRequester) => this;

                                                                                                  method withStart

                                                                                                  withStart: (start: MetadataRequester) => this;

                                                                                                    class Server

                                                                                                    class Server {}

                                                                                                      constructor

                                                                                                      constructor(options?: ChannelOptions);

                                                                                                        method addHttp2Port

                                                                                                        addHttp2Port: () => void;

                                                                                                          method addProtoService

                                                                                                          addProtoService: () => void;

                                                                                                            method addService

                                                                                                            addService: (
                                                                                                            service: ServiceDefinition,
                                                                                                            implementation: UntypedServiceImplementation
                                                                                                            ) => void;

                                                                                                              method bind

                                                                                                              bind: (port: string, creds: ServerCredentials) => void;

                                                                                                                method bindAsync

                                                                                                                bindAsync: (
                                                                                                                port: string,
                                                                                                                creds: ServerCredentials,
                                                                                                                callback: (error: Error | null, port: number) => void
                                                                                                                ) => void;

                                                                                                                  method forceShutdown

                                                                                                                  forceShutdown: () => void;

                                                                                                                    method register

                                                                                                                    register: <RequestType, ResponseType>(
                                                                                                                    name: string,
                                                                                                                    handler: HandleCall<RequestType, ResponseType>,
                                                                                                                    serialize: Serialize<ResponseType>,
                                                                                                                    deserialize: Deserialize<RequestType>,
                                                                                                                    type: string
                                                                                                                    ) => boolean;

                                                                                                                      method removeService

                                                                                                                      removeService: (service: ServiceDefinition) => void;

                                                                                                                        method start

                                                                                                                        start: () => void;

                                                                                                                          method tryShutdown

                                                                                                                          tryShutdown: (callback: (error?: Error) => void) => void;

                                                                                                                            method unregister

                                                                                                                            unregister: (name: string) => boolean;

                                                                                                                              class ServerCredentials

                                                                                                                              abstract class ServerCredentials {}

                                                                                                                                method createInsecure

                                                                                                                                static createInsecure: () => ServerCredentials;

                                                                                                                                  method createSsl

                                                                                                                                  static createSsl: (
                                                                                                                                  rootCerts: Buffer | null,
                                                                                                                                  keyCertPairs: KeyCertPair[],
                                                                                                                                  checkClientCertificate?: boolean
                                                                                                                                  ) => ServerCredentials;

                                                                                                                                    class StatusBuilder

                                                                                                                                    class StatusBuilder {}
                                                                                                                                    • A builder for gRPC status objects.

                                                                                                                                    constructor

                                                                                                                                    constructor();

                                                                                                                                      method build

                                                                                                                                      build: () => Partial<StatusObject>;
                                                                                                                                      • Builds the status object.

                                                                                                                                      method withCode

                                                                                                                                      withCode: (code: Status) => this;
                                                                                                                                      • Adds a status code to the builder.

                                                                                                                                      method withDetails

                                                                                                                                      withDetails: (details: string) => this;
                                                                                                                                      • Adds details to the builder.

                                                                                                                                      method withMetadata

                                                                                                                                      withMetadata: (metadata: Metadata) => this;
                                                                                                                                      • Adds metadata to the builder.

                                                                                                                                      Interfaces

                                                                                                                                      interface CallInvocationTransformer

                                                                                                                                      interface CallInvocationTransformer {}

                                                                                                                                        call signature

                                                                                                                                        (callProperties: CallProperties<any, any>): CallProperties<any, any>;

                                                                                                                                          interface CallOptions

                                                                                                                                          interface CallOptions {}

                                                                                                                                            property credentials

                                                                                                                                            credentials?: CallCredentials;

                                                                                                                                              property deadline

                                                                                                                                              deadline?: Deadline;

                                                                                                                                                property host

                                                                                                                                                host?: string;

                                                                                                                                                  property interceptor_providers

                                                                                                                                                  interceptor_providers?: InterceptorProvider[];

                                                                                                                                                    property interceptors

                                                                                                                                                    interceptors?: Interceptor[];

                                                                                                                                                      property parent

                                                                                                                                                      parent?:
                                                                                                                                                      | ServerUnaryCall<any, any>
                                                                                                                                                      | ServerReadableStream<any, any>
                                                                                                                                                      | ServerWritableStream<any, any>
                                                                                                                                                      | ServerDuplexStream<any, any>;

                                                                                                                                                        property propagate_flags

                                                                                                                                                        propagate_flags?: number;

                                                                                                                                                          interface CallProperties

                                                                                                                                                          interface CallProperties<RequestType, ResponseType> {}

                                                                                                                                                            property argument

                                                                                                                                                            argument?: RequestType;

                                                                                                                                                              property call

                                                                                                                                                              call: SurfaceCall;

                                                                                                                                                                property callback

                                                                                                                                                                callback?: UnaryCallback<ResponseType>;

                                                                                                                                                                  property callOptions

                                                                                                                                                                  callOptions: CallOptions;

                                                                                                                                                                    property channel

                                                                                                                                                                    channel: Channel;

                                                                                                                                                                      property metadata

                                                                                                                                                                      metadata: Metadata;

                                                                                                                                                                        property methodDefinition

                                                                                                                                                                        methodDefinition: ClientMethodDefinition<RequestType, ResponseType>;

                                                                                                                                                                          interface ChannelInterface

                                                                                                                                                                          interface Channel {}
                                                                                                                                                                          • An interface that represents a communication channel to a server specified by a given address.

                                                                                                                                                                          method close

                                                                                                                                                                          close: () => void;
                                                                                                                                                                          • Close the channel. This has the same functionality as the existing grpc.Client.prototype.close

                                                                                                                                                                          method createCall

                                                                                                                                                                          createCall: (
                                                                                                                                                                          method: string,
                                                                                                                                                                          deadline: Deadline,
                                                                                                                                                                          host: string | null | undefined,
                                                                                                                                                                          parentCall: ServerSurfaceCall | null,
                                                                                                                                                                          propagateFlags: number | null | undefined
                                                                                                                                                                          ) => Call;
                                                                                                                                                                          • Create a call object. Call is an opaque type that is used by the Client class. This function is called by the gRPC library when starting a request. Implementers should return an instance of Call that is returned from calling createCall on an instance of the provided Channel class.

                                                                                                                                                                            Parameter method

                                                                                                                                                                            The full method string to request.

                                                                                                                                                                            Parameter deadline

                                                                                                                                                                            The call deadline

                                                                                                                                                                            Parameter host

                                                                                                                                                                            A host string override for making the request

                                                                                                                                                                            Parameter parentCall

                                                                                                                                                                            A server call to propagate some information from

                                                                                                                                                                            Parameter propagateFlags

                                                                                                                                                                            A bitwise combination of elements of grpc.propagate that indicates what information to propagate from parentCall.

                                                                                                                                                                          method getConnectivityState

                                                                                                                                                                          getConnectivityState: (tryToConnect: boolean) => ConnectivityState;
                                                                                                                                                                          • Get the channel's current connectivity state. This method is here mainly because it is in the existing internal Channel class, and there isn't another good place to put it.

                                                                                                                                                                            Parameter tryToConnect

                                                                                                                                                                            If true, the channel will start connecting if it is idle. Otherwise, idle channels will only start connecting when a call starts.

                                                                                                                                                                          method getTarget

                                                                                                                                                                          getTarget: () => string;
                                                                                                                                                                          • Return the target that this channel connects to

                                                                                                                                                                          method watchConnectivityState

                                                                                                                                                                          watchConnectivityState: (
                                                                                                                                                                          currentState: ConnectivityState,
                                                                                                                                                                          deadline: Date | number,
                                                                                                                                                                          callback: (error?: Error) => void
                                                                                                                                                                          ) => void;
                                                                                                                                                                          • Watch for connectivity state changes. This is also here mainly because it is in the existing external Channel class.

                                                                                                                                                                            Parameter currentState

                                                                                                                                                                            The state to watch for transitions from. This should always be populated by calling getConnectivityState immediately before.

                                                                                                                                                                            Parameter deadline

                                                                                                                                                                            A deadline for waiting for a state change

                                                                                                                                                                            Parameter callback

                                                                                                                                                                            Called with no error when a state change, or with an error if the deadline passes without a state change.

                                                                                                                                                                          interface ChannelOptions

                                                                                                                                                                          interface ChannelOptions {}
                                                                                                                                                                          • An interface that contains options used when initializing a Channel instance.

                                                                                                                                                                          property 'grpc-node.max_session_memory'

                                                                                                                                                                          'grpc-node.max_session_memory'?: number;

                                                                                                                                                                            property 'grpc.default_authority'

                                                                                                                                                                            'grpc.default_authority'?: string;

                                                                                                                                                                              property 'grpc.enable_http_proxy'

                                                                                                                                                                              'grpc.enable_http_proxy'?: number;

                                                                                                                                                                                property 'grpc.http_connect_creds'

                                                                                                                                                                                'grpc.http_connect_creds'?: string;

                                                                                                                                                                                  property 'grpc.http_connect_target'

                                                                                                                                                                                  'grpc.http_connect_target'?: string;

                                                                                                                                                                                    property 'grpc.initial_reconnect_backoff_ms'

                                                                                                                                                                                    'grpc.initial_reconnect_backoff_ms'?: number;

                                                                                                                                                                                      property 'grpc.keepalive_permit_without_calls'

                                                                                                                                                                                      'grpc.keepalive_permit_without_calls'?: number;

                                                                                                                                                                                        property 'grpc.keepalive_time_ms'

                                                                                                                                                                                        'grpc.keepalive_time_ms'?: number;

                                                                                                                                                                                          property 'grpc.keepalive_timeout_ms'

                                                                                                                                                                                          'grpc.keepalive_timeout_ms'?: number;

                                                                                                                                                                                            property 'grpc.max_concurrent_streams'

                                                                                                                                                                                            'grpc.max_concurrent_streams'?: number;

                                                                                                                                                                                              property 'grpc.max_receive_message_length'

                                                                                                                                                                                              'grpc.max_receive_message_length'?: number;

                                                                                                                                                                                                property 'grpc.max_reconnect_backoff_ms'

                                                                                                                                                                                                'grpc.max_reconnect_backoff_ms'?: number;

                                                                                                                                                                                                  property 'grpc.max_send_message_length'

                                                                                                                                                                                                  'grpc.max_send_message_length'?: number;

                                                                                                                                                                                                    property 'grpc.primary_user_agent'

                                                                                                                                                                                                    'grpc.primary_user_agent'?: string;

                                                                                                                                                                                                      property 'grpc.secondary_user_agent'

                                                                                                                                                                                                      'grpc.secondary_user_agent'?: string;

                                                                                                                                                                                                        property 'grpc.service_config'

                                                                                                                                                                                                        'grpc.service_config'?: string;

                                                                                                                                                                                                          property 'grpc.ssl_target_name_override'

                                                                                                                                                                                                          'grpc.ssl_target_name_override'?: string;

                                                                                                                                                                                                            property 'grpc.use_local_subchannel_pool'

                                                                                                                                                                                                            'grpc.use_local_subchannel_pool'?: number;

                                                                                                                                                                                                              index signature

                                                                                                                                                                                                              [key: string]: any;

                                                                                                                                                                                                                interface deserialize

                                                                                                                                                                                                                interface Deserialize<T> {}

                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                  (bytes: Buffer): T;

                                                                                                                                                                                                                    interface GrpcObject

                                                                                                                                                                                                                    interface GrpcObject {}

                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                      [index: string]: GrpcObject | ServiceClientConstructor | ProtobufTypeDefinition;

                                                                                                                                                                                                                        interface Interceptor

                                                                                                                                                                                                                        interface Interceptor {}

                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                          (options: InterceptorOptions, nextCall: NextCall): InterceptingCall;

                                                                                                                                                                                                                            interface InterceptorOptions

                                                                                                                                                                                                                            interface InterceptorOptions extends CallOptions {}

                                                                                                                                                                                                                              property method_definition

                                                                                                                                                                                                                              method_definition: ClientMethodDefinition<any, any>;

                                                                                                                                                                                                                                interface InterceptorProvider

                                                                                                                                                                                                                                interface InterceptorProvider {}

                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                  (methodDefinition: ClientMethodDefinition<any, any>): Interceptor;

                                                                                                                                                                                                                                    interface KeyCertPair

                                                                                                                                                                                                                                    interface KeyCertPair {}

                                                                                                                                                                                                                                      property cert_chain

                                                                                                                                                                                                                                      cert_chain: Buffer;

                                                                                                                                                                                                                                        property private_key

                                                                                                                                                                                                                                        private_key: Buffer;

                                                                                                                                                                                                                                          interface MethodDefinition

                                                                                                                                                                                                                                          interface MethodDefinition<RequestType, ResponseType>
                                                                                                                                                                                                                                          extends ClientMethodDefinition<RequestType, ResponseType>,
                                                                                                                                                                                                                                          ServerMethodDefinition<RequestType, ResponseType> {}

                                                                                                                                                                                                                                            interface requestCallback

                                                                                                                                                                                                                                            interface UnaryCallback<ResponseType> {}

                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                              (err: ServiceError | null, value?: ResponseType): void;

                                                                                                                                                                                                                                                interface serialize

                                                                                                                                                                                                                                                interface Serialize<T> {}

                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                  (value: T): Buffer;

                                                                                                                                                                                                                                                    interface StatusObject

                                                                                                                                                                                                                                                    interface StatusObject {}

                                                                                                                                                                                                                                                      property code

                                                                                                                                                                                                                                                      code: Status;

                                                                                                                                                                                                                                                        property details

                                                                                                                                                                                                                                                        details: string;

                                                                                                                                                                                                                                                          property metadata

                                                                                                                                                                                                                                                          metadata: Metadata;

                                                                                                                                                                                                                                                            interface UntypedServiceImplementation

                                                                                                                                                                                                                                                            interface UntypedServiceImplementation {}

                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                              [name: string]: UntypedHandleCall;

                                                                                                                                                                                                                                                                Enums

                                                                                                                                                                                                                                                                enum connectivityState

                                                                                                                                                                                                                                                                enum connectivityState {
                                                                                                                                                                                                                                                                IDLE = 0,
                                                                                                                                                                                                                                                                CONNECTING = 1,
                                                                                                                                                                                                                                                                READY = 2,
                                                                                                                                                                                                                                                                TRANSIENT_FAILURE = 3,
                                                                                                                                                                                                                                                                SHUTDOWN = 4,
                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                  member CONNECTING

                                                                                                                                                                                                                                                                  CONNECTING = 1

                                                                                                                                                                                                                                                                    member IDLE

                                                                                                                                                                                                                                                                    IDLE = 0

                                                                                                                                                                                                                                                                      member READY

                                                                                                                                                                                                                                                                      READY = 2

                                                                                                                                                                                                                                                                        member SHUTDOWN

                                                                                                                                                                                                                                                                        SHUTDOWN = 4

                                                                                                                                                                                                                                                                          member TRANSIENT_FAILURE

                                                                                                                                                                                                                                                                          TRANSIENT_FAILURE = 3

                                                                                                                                                                                                                                                                            enum logVerbosity

                                                                                                                                                                                                                                                                            enum logVerbosity {
                                                                                                                                                                                                                                                                            DEBUG = 0,
                                                                                                                                                                                                                                                                            INFO = 1,
                                                                                                                                                                                                                                                                            ERROR = 2,
                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                              member DEBUG

                                                                                                                                                                                                                                                                              DEBUG = 0

                                                                                                                                                                                                                                                                                member ERROR

                                                                                                                                                                                                                                                                                ERROR = 2

                                                                                                                                                                                                                                                                                  member INFO

                                                                                                                                                                                                                                                                                  INFO = 1

                                                                                                                                                                                                                                                                                    enum propagate

                                                                                                                                                                                                                                                                                    enum propagate {
                                                                                                                                                                                                                                                                                    DEADLINE = 1,
                                                                                                                                                                                                                                                                                    CENSUS_STATS_CONTEXT = 2,
                                                                                                                                                                                                                                                                                    CENSUS_TRACING_CONTEXT = 4,
                                                                                                                                                                                                                                                                                    CANCELLATION = 8,
                                                                                                                                                                                                                                                                                    DEFAULTS = 65535,
                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                    • NOTE: This enum is not currently used in any implemented API in this library. It is included only for type parity with the other implementation.

                                                                                                                                                                                                                                                                                    member CANCELLATION

                                                                                                                                                                                                                                                                                    CANCELLATION = 8

                                                                                                                                                                                                                                                                                      member CENSUS_STATS_CONTEXT

                                                                                                                                                                                                                                                                                      CENSUS_STATS_CONTEXT = 2

                                                                                                                                                                                                                                                                                        member CENSUS_TRACING_CONTEXT

                                                                                                                                                                                                                                                                                        CENSUS_TRACING_CONTEXT = 4

                                                                                                                                                                                                                                                                                          member DEADLINE

                                                                                                                                                                                                                                                                                          DEADLINE = 1

                                                                                                                                                                                                                                                                                            member DEFAULTS

                                                                                                                                                                                                                                                                                            DEFAULTS = 65535

                                                                                                                                                                                                                                                                                              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,
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                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

                                                                                                                                                                                                                                                                                                                                  Type Aliases

                                                                                                                                                                                                                                                                                                                                  type Call

                                                                                                                                                                                                                                                                                                                                  type Call =
                                                                                                                                                                                                                                                                                                                                  | ClientUnaryCall
                                                                                                                                                                                                                                                                                                                                  | ClientReadableStream<any>
                                                                                                                                                                                                                                                                                                                                  | ClientWritableStream<any>
                                                                                                                                                                                                                                                                                                                                  | ClientDuplexStream<any, any>;

                                                                                                                                                                                                                                                                                                                                    type ClientDuplexStream

                                                                                                                                                                                                                                                                                                                                    type ClientDuplexStream<
                                                                                                                                                                                                                                                                                                                                    RequestType,
                                                                                                                                                                                                                                                                                                                                    ResponseType
                                                                                                                                                                                                                                                                                                                                    > = ClientWritableStream<RequestType> & ClientReadableStream<ResponseType>;
                                                                                                                                                                                                                                                                                                                                    • A type representing the return value of a bidirectional stream method call.

                                                                                                                                                                                                                                                                                                                                    type ClientOptions

                                                                                                                                                                                                                                                                                                                                    type ClientOptions = Partial<ChannelOptions> & {
                                                                                                                                                                                                                                                                                                                                    channelOverride?: Channel;
                                                                                                                                                                                                                                                                                                                                    channelFactoryOverride?: (
                                                                                                                                                                                                                                                                                                                                    address: string,
                                                                                                                                                                                                                                                                                                                                    credentials: ChannelCredentials,
                                                                                                                                                                                                                                                                                                                                    options: ClientOptions
                                                                                                                                                                                                                                                                                                                                    ) => Channel;
                                                                                                                                                                                                                                                                                                                                    interceptors?: Interceptor[];
                                                                                                                                                                                                                                                                                                                                    interceptor_providers?: InterceptorProvider[];
                                                                                                                                                                                                                                                                                                                                    callInvocationTransformer?: CallInvocationTransformer;
                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                      type ClientReadableStream

                                                                                                                                                                                                                                                                                                                                      type ClientReadableStream<ResponseType> = {
                                                                                                                                                                                                                                                                                                                                      deserialize: (chunk: Buffer) => ResponseType;
                                                                                                                                                                                                                                                                                                                                      } & SurfaceCall &
                                                                                                                                                                                                                                                                                                                                      ObjectReadable<ResponseType>;
                                                                                                                                                                                                                                                                                                                                      • A type representing the return value of a server stream method call.

                                                                                                                                                                                                                                                                                                                                      type ClientUnaryCall

                                                                                                                                                                                                                                                                                                                                      type ClientUnaryCall = SurfaceCall;
                                                                                                                                                                                                                                                                                                                                      • A type representing the return value of a unary method call.

                                                                                                                                                                                                                                                                                                                                      type ClientWritableStream

                                                                                                                                                                                                                                                                                                                                      type ClientWritableStream<RequestType> = {
                                                                                                                                                                                                                                                                                                                                      serialize: (value: RequestType) => Buffer;
                                                                                                                                                                                                                                                                                                                                      } & SurfaceCall &
                                                                                                                                                                                                                                                                                                                                      ObjectWritable<RequestType>;
                                                                                                                                                                                                                                                                                                                                      • A type representing the return value of a client stream method call.

                                                                                                                                                                                                                                                                                                                                      type Deadline

                                                                                                                                                                                                                                                                                                                                      type Deadline = Date | number;

                                                                                                                                                                                                                                                                                                                                        type handleBidiStreamingCall

                                                                                                                                                                                                                                                                                                                                        type handleBidiStreamingCall<RequestType, ResponseType> = (
                                                                                                                                                                                                                                                                                                                                        call: ServerDuplexStream<RequestType, ResponseType>
                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                          type handleClientStreamingCall

                                                                                                                                                                                                                                                                                                                                          type handleClientStreamingCall<RequestType, ResponseType> = (
                                                                                                                                                                                                                                                                                                                                          call: ServerReadableStream<RequestType, ResponseType>,
                                                                                                                                                                                                                                                                                                                                          callback: sendUnaryData<ResponseType>
                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                            type handleServerStreamingCall

                                                                                                                                                                                                                                                                                                                                            type handleServerStreamingCall<RequestType, ResponseType> = (
                                                                                                                                                                                                                                                                                                                                            call: ServerWritableStream<RequestType, ResponseType>
                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                              type handleUnaryCall

                                                                                                                                                                                                                                                                                                                                              type handleUnaryCall<RequestType, ResponseType> = (
                                                                                                                                                                                                                                                                                                                                              call: ServerUnaryCall<RequestType, ResponseType>,
                                                                                                                                                                                                                                                                                                                                              callback: sendUnaryData<ResponseType>
                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                type Listener

                                                                                                                                                                                                                                                                                                                                                type Listener = Partial<FullListener>;

                                                                                                                                                                                                                                                                                                                                                  type MetadataValue

                                                                                                                                                                                                                                                                                                                                                  type MetadataValue = string | Buffer;

                                                                                                                                                                                                                                                                                                                                                    type OAuth2Client

                                                                                                                                                                                                                                                                                                                                                    type OAuth2Client = OldOAuth2Client | CurrentOAuth2Client;

                                                                                                                                                                                                                                                                                                                                                      type Requester

                                                                                                                                                                                                                                                                                                                                                      type Requester = Partial<FullRequester>;

                                                                                                                                                                                                                                                                                                                                                        type sendUnaryData

                                                                                                                                                                                                                                                                                                                                                        type sendUnaryData<ResponseType> = (
                                                                                                                                                                                                                                                                                                                                                        error: ServerErrorResponse | ServerStatusResponse | null,
                                                                                                                                                                                                                                                                                                                                                        value?: ResponseType | null,
                                                                                                                                                                                                                                                                                                                                                        trailer?: Metadata,
                                                                                                                                                                                                                                                                                                                                                        flags?: number
                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                          type ServerDuplexStream

                                                                                                                                                                                                                                                                                                                                                          type ServerDuplexStream<RequestType, ResponseType> = ServerSurfaceCall &
                                                                                                                                                                                                                                                                                                                                                          ObjectReadable<RequestType> &
                                                                                                                                                                                                                                                                                                                                                          ObjectWritable<ResponseType> & {
                                                                                                                                                                                                                                                                                                                                                          end: (metadata?: Metadata) => void;
                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                            type ServerReadableStream

                                                                                                                                                                                                                                                                                                                                                            type ServerReadableStream<RequestType, ResponseType> = ServerSurfaceCall &
                                                                                                                                                                                                                                                                                                                                                            ObjectReadable<RequestType>;

                                                                                                                                                                                                                                                                                                                                                              type ServerUnaryCall

                                                                                                                                                                                                                                                                                                                                                              type ServerUnaryCall<RequestType, ResponseType> = ServerSurfaceCall & {
                                                                                                                                                                                                                                                                                                                                                              request: RequestType;
                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                type ServerWritableStream

                                                                                                                                                                                                                                                                                                                                                                type ServerWritableStream<RequestType, ResponseType> = ServerSurfaceCall &
                                                                                                                                                                                                                                                                                                                                                                ObjectWritable<ResponseType> & {
                                                                                                                                                                                                                                                                                                                                                                request: RequestType;
                                                                                                                                                                                                                                                                                                                                                                end: (metadata?: Metadata) => void;
                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                  type ServiceDefinition

                                                                                                                                                                                                                                                                                                                                                                  type ServiceDefinition<ImplementationType = UntypedServiceImplementation> = {
                                                                                                                                                                                                                                                                                                                                                                  readonly [index in keyof ImplementationType]: MethodDefinition<any, any>;
                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                    type ServiceError

                                                                                                                                                                                                                                                                                                                                                                    type ServiceError = StatusObject & Error;
                                                                                                                                                                                                                                                                                                                                                                    • A type extending the built-in Error object with additional fields.

                                                                                                                                                                                                                                                                                                                                                                    type UntypedHandleCall

                                                                                                                                                                                                                                                                                                                                                                    type UntypedHandleCall = HandleCall<any, any>;

                                                                                                                                                                                                                                                                                                                                                                      Namespaces

                                                                                                                                                                                                                                                                                                                                                                      namespace experimental

                                                                                                                                                                                                                                                                                                                                                                      module 'build/src/experimental.d.ts' {}

                                                                                                                                                                                                                                                                                                                                                                        function getFirstUsableConfig

                                                                                                                                                                                                                                                                                                                                                                        getFirstUsableConfig: (
                                                                                                                                                                                                                                                                                                                                                                        configs: LoadBalancingConfig[],
                                                                                                                                                                                                                                                                                                                                                                        defaultPickFirst?: true
                                                                                                                                                                                                                                                                                                                                                                        ) => LoadBalancingConfig;

                                                                                                                                                                                                                                                                                                                                                                          function registerLoadBalancerType

                                                                                                                                                                                                                                                                                                                                                                          registerLoadBalancerType: (
                                                                                                                                                                                                                                                                                                                                                                          typeName: string,
                                                                                                                                                                                                                                                                                                                                                                          loadBalancerType: LoadBalancerConstructor,
                                                                                                                                                                                                                                                                                                                                                                          loadBalancingConfigType: LoadBalancingConfigConstructor
                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                            function registerResolver

                                                                                                                                                                                                                                                                                                                                                                            registerResolver: (scheme: string, resolverClass: ResolverConstructor) => void;
                                                                                                                                                                                                                                                                                                                                                                            • Register a resolver class to handle target names prefixed with the prefix string. This prefix should correspond to a URI scheme name listed in the [gRPC Name Resolution document](https://github.com/grpc/grpc/blob/master/doc/naming.md)

                                                                                                                                                                                                                                                                                                                                                                              Parameter prefix

                                                                                                                                                                                                                                                                                                                                                                              Parameter resolverClass

                                                                                                                                                                                                                                                                                                                                                                            function subchannelAddressToString

                                                                                                                                                                                                                                                                                                                                                                            subchannelAddressToString: (address: SubchannelAddress) => string;

                                                                                                                                                                                                                                                                                                                                                                              function trace

                                                                                                                                                                                                                                                                                                                                                                              trace: (severity: LogVerbosity, tracer: string, text: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                function uriToString

                                                                                                                                                                                                                                                                                                                                                                                uriToString: (uri: GrpcUri) => string;

                                                                                                                                                                                                                                                                                                                                                                                  function validateLoadBalancingConfig

                                                                                                                                                                                                                                                                                                                                                                                  validateLoadBalancingConfig: (obj: any) => LoadBalancingConfig;

                                                                                                                                                                                                                                                                                                                                                                                    class BackoffTimeout

                                                                                                                                                                                                                                                                                                                                                                                    class BackoffTimeout {}

                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                      constructor(callback: () => void, options?: BackoffOptions);

                                                                                                                                                                                                                                                                                                                                                                                        method isRunning

                                                                                                                                                                                                                                                                                                                                                                                        isRunning: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                          method ref

                                                                                                                                                                                                                                                                                                                                                                                          ref: () => void;

                                                                                                                                                                                                                                                                                                                                                                                            method reset

                                                                                                                                                                                                                                                                                                                                                                                            reset: () => void;
                                                                                                                                                                                                                                                                                                                                                                                            • Reset the delay time to its initial value.

                                                                                                                                                                                                                                                                                                                                                                                            method runOnce

                                                                                                                                                                                                                                                                                                                                                                                            runOnce: () => void;
                                                                                                                                                                                                                                                                                                                                                                                            • Call the callback after the current amount of delay time

                                                                                                                                                                                                                                                                                                                                                                                            method stop

                                                                                                                                                                                                                                                                                                                                                                                            stop: () => void;
                                                                                                                                                                                                                                                                                                                                                                                            • Stop the timer. The callback will not be called until runOnce is called again.

                                                                                                                                                                                                                                                                                                                                                                                            method unref

                                                                                                                                                                                                                                                                                                                                                                                            unref: () => void;

                                                                                                                                                                                                                                                                                                                                                                                              class BaseFilter

                                                                                                                                                                                                                                                                                                                                                                                              abstract class BaseFilter implements Filter {}

                                                                                                                                                                                                                                                                                                                                                                                                method receiveMessage

                                                                                                                                                                                                                                                                                                                                                                                                receiveMessage: (message: Promise<Buffer>) => Promise<Buffer>;

                                                                                                                                                                                                                                                                                                                                                                                                  method receiveMetadata

                                                                                                                                                                                                                                                                                                                                                                                                  receiveMetadata: (metadata: Metadata) => Metadata;

                                                                                                                                                                                                                                                                                                                                                                                                    method receiveTrailers

                                                                                                                                                                                                                                                                                                                                                                                                    receiveTrailers: (status: StatusObject) => StatusObject;

                                                                                                                                                                                                                                                                                                                                                                                                      method sendMessage

                                                                                                                                                                                                                                                                                                                                                                                                      sendMessage: (message: Promise<WriteObject>) => Promise<WriteObject>;

                                                                                                                                                                                                                                                                                                                                                                                                        method sendMetadata

                                                                                                                                                                                                                                                                                                                                                                                                        sendMetadata: (metadata: Promise<Metadata>) => Promise<Metadata>;

                                                                                                                                                                                                                                                                                                                                                                                                          class ChildLoadBalancerHandler

                                                                                                                                                                                                                                                                                                                                                                                                          class ChildLoadBalancerHandler implements LoadBalancer {}

                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                            constructor(channelControlHelper: ChannelControlHelper);

                                                                                                                                                                                                                                                                                                                                                                                                              method destroy

                                                                                                                                                                                                                                                                                                                                                                                                              destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                method exitIdle

                                                                                                                                                                                                                                                                                                                                                                                                                exitIdle: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                  method getTypeName

                                                                                                                                                                                                                                                                                                                                                                                                                  getTypeName: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                    method resetBackoff

                                                                                                                                                                                                                                                                                                                                                                                                                    resetBackoff: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                      method updateAddressList

                                                                                                                                                                                                                                                                                                                                                                                                                      updateAddressList: (
                                                                                                                                                                                                                                                                                                                                                                                                                      addressList: SubchannelAddress[],
                                                                                                                                                                                                                                                                                                                                                                                                                      lbConfig: LoadBalancingConfig,
                                                                                                                                                                                                                                                                                                                                                                                                                      attributes: { [key: string]: unknown }
                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Prerequisites: lbConfig !== null and lbConfig.name is registered

                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter addressList

                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter lbConfig

                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter attributes

                                                                                                                                                                                                                                                                                                                                                                                                                      class FilterStackFactory

                                                                                                                                                                                                                                                                                                                                                                                                                      class FilterStackFactory implements FilterFactory<FilterStack> {}

                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(factories: FilterFactory<Filter>[]);

                                                                                                                                                                                                                                                                                                                                                                                                                          method createFilter

                                                                                                                                                                                                                                                                                                                                                                                                                          createFilter: (callStream: Call) => FilterStack;

                                                                                                                                                                                                                                                                                                                                                                                                                            class QueuePicker

                                                                                                                                                                                                                                                                                                                                                                                                                            class QueuePicker {}
                                                                                                                                                                                                                                                                                                                                                                                                                            • A standard picker representing a load balancer in the IDLE or CONNECTING state. Always responds to every pick request with a QUEUE pick result indicating that the pick should be tried again with the next Picker. Also reports back to the load balancer that a connection should be established once any pick is attempted.

                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(loadBalancer: LoadBalancer);

                                                                                                                                                                                                                                                                                                                                                                                                                              method pick

                                                                                                                                                                                                                                                                                                                                                                                                                              pick: (pickArgs: PickArgs) => QueuePickResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                class UnavailablePicker

                                                                                                                                                                                                                                                                                                                                                                                                                                class UnavailablePicker implements Picker {}
                                                                                                                                                                                                                                                                                                                                                                                                                                • A standard picker representing a load balancer in the TRANSIENT_FAILURE state. Always responds to every pick request with an UNAVAILABLE status.

                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(status?: StatusObject);

                                                                                                                                                                                                                                                                                                                                                                                                                                  method pick

                                                                                                                                                                                                                                                                                                                                                                                                                                  pick: (pickArgs: PickArgs) => TransientFailurePickResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CallStream

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Call {}

                                                                                                                                                                                                                                                                                                                                                                                                                                      method cancelWithStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                      cancelWithStatus: (status: Status, details: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method getCredentials

                                                                                                                                                                                                                                                                                                                                                                                                                                        getCredentials: () => CallCredentials;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method getDeadline

                                                                                                                                                                                                                                                                                                                                                                                                                                          getDeadline: () => Deadline;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method getHost

                                                                                                                                                                                                                                                                                                                                                                                                                                            getHost: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method getMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                              getMethod: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method getPeer

                                                                                                                                                                                                                                                                                                                                                                                                                                                getPeer: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method halfClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                  halfClose: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method sendMessageWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                    sendMessageWithContext: (context: MessageContext, message: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method setCredentials

                                                                                                                                                                                                                                                                                                                                                                                                                                                      setCredentials: (credentials: CallCredentials) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method start

                                                                                                                                                                                                                                                                                                                                                                                                                                                        start: (metadata: Metadata, listener: InterceptingListener) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method startRead

                                                                                                                                                                                                                                                                                                                                                                                                                                                          startRead: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ChannelControlHelper

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ChannelControlHelper {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • A collection of functions associated with a channel that a load balancer can call as necessary.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method createSubchannel

                                                                                                                                                                                                                                                                                                                                                                                                                                                            createSubchannel: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                            subchannelAddress: SubchannelAddress,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            subchannelArgs: ChannelOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Subchannel;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Returns a subchannel connected to the specified address.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter subchannelAddress

                                                                                                                                                                                                                                                                                                                                                                                                                                                              The address to connect to

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter subchannelArgs

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Extra channel arguments specified by the load balancer

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method requestReresolution

                                                                                                                                                                                                                                                                                                                                                                                                                                                            requestReresolution: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Request new data from the resolver.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method updateState

                                                                                                                                                                                                                                                                                                                                                                                                                                                            updateState: (connectivityState: ConnectivityState, picker: Picker) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Passes a new subchannel picker up to the channel. This is called if either the connectivity state changes or if a different picker is needed for any other reason.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter connectivityState

                                                                                                                                                                                                                                                                                                                                                                                                                                                              New connectivity state

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter picker

                                                                                                                                                                                                                                                                                                                                                                                                                                                              New picker

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ConfigSelector

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ConfigSelector {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Selects a configuration for a method given the name and metadata. Defined in https://github.com/grpc/proposal/blob/master/A31-xds-timeout-support-and-config-selector.md#new-functionality-in-grpc

                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                            (methodName: string, metadata: Metadata): CallConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Filter {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Filter classes represent related per-call logic and state that is primarily used to modify incoming and outgoing data

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method receiveMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                              receiveMessage: (message: Promise<Buffer>) => Promise<Buffer>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method receiveMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                receiveMetadata: (metadata: Metadata) => Metadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method receiveTrailers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  receiveTrailers: (status: StatusObject) => StatusObject;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method sendMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sendMessage: (message: Promise<WriteObject>) => Promise<WriteObject>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method sendMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sendMetadata: (metadata: Promise<Metadata>) => Promise<Metadata>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface FilterFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface FilterFactory<T extends Filter> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method createFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createFilter: (callStream: Call) => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GrpcUri

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GrpcUri {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property authority

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              authority?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property scheme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  scheme?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface LoadBalancer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface LoadBalancer {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Tracks one or more connected subchannels and determines which subchannel each request should use.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method destroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    destroy: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The load balancer unrefs all of its subchannels and stops calling methods of its channel control helper.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method exitIdle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    exitIdle: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • If the load balancer is currently in the IDLE state, start connecting.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getTypeName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getTypeName: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Get the type name for this load balancer type. Must be constant across an entire load balancer implementation class and must match the name that the balancer implementation class was registered with.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method resetBackoff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    resetBackoff: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • If the load balancer is currently in the CONNECTING or TRANSIENT_FAILURE state, reset the current connection backoff timeout to its base value and transition to CONNECTING if in TRANSIENT_FAILURE.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method updateAddressList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    updateAddressList: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    addressList: SubchannelAddress[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    lbConfig: LoadBalancingConfig,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    attributes: { [key: string]: unknown }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Gives the load balancer a new list of addresses to start connecting to. The load balancer will start establishing connections with the new list, but will continue using any existing connections until the new connections are established

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter addressList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The new list of addresses to connect to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter lbConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The load balancing config object from the service config, if one was provided

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface LoadBalancingConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface LoadBalancingConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getLoadBalancerName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getLoadBalancerName: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method toJsonObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        toJsonObject: () => object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PickArgs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PickArgs {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property extraPickInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            extraPickInfo: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [key: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              metadata: Metadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Picker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Picker {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • A proxy object representing the momentary state of a load balancer. Picks subchannels or returns other information based on that state. Should be replaced every time the load balancer changes state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method pick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                pick: (pickArgs: PickArgs) => PickResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PickResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PickResult {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property extraFilterFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    extraFilterFactory: FilterFactory<Filter> | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Extra FilterFactory (can be multiple encapsulated in a FilterStackFactory) provided by the load balancer to be used with the call. For technical reasons filters from this factory will not see sendMetadata events.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onCallStarted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onCallStarted: (() => void) | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property pickResultType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pickResultType: PickResultType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        status: StatusObject | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • The status object to end the call with. Populated if and only if pickResultType is TRANSIENT_FAILURE.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property subchannel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        subchannel: Subchannel | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • The subchannel to use as the transport for the call. Only meaningful if pickResultType is COMPLETE. If null, indicates that the call should be dropped.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Resolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Resolver {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • A resolver class that handles one or more of the name syntax schemes defined in the [gRPC Name Resolution document](https://github.com/grpc/grpc/blob/master/doc/naming.md)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method destroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        destroy: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Destroy the resolver. Should be called when the owning channel shuts down.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method updateResolution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        updateResolution: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the caller wants new name resolution data. Calling this function may eventually result in calling one of the ResolverListener functions, but that is not guaranteed. Those functions will never be called synchronously with the constructor or updateResolution.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ResolverListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ResolverListener {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • A listener object passed to the resolver's constructor that provides name resolution updates back to the resolver's owner.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method onError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onError: (error: StatusObject) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Called whenever a name resolution attempt fails.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Describes how resolution failed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method onSuccessfulResolution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onSuccessfulResolution: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        addressList: SubchannelAddress[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        serviceConfig: ServiceConfig | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        serviceConfigError: StatusObject | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        configSelector: ConfigSelector | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        attributes: { [key: string]: unknown }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Called whenever the resolver has new name resolution results to report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter addressList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The new list of backend addresses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter serviceConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The new service configuration corresponding to the addressList. Will be null if no service configuration was retrieved or if the service configuration was invalid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter serviceConfigError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If non-null, indicates that the retrieved service configuration was invalid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ServiceConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ServiceConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property loadBalancingConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          loadBalancingConfig: LoadBalancingConfig[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property loadBalancingPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            loadBalancingPolicy?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property methodConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              methodConfig: MethodConfig[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enum PickResultType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enum PickResultType {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                COMPLETE = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                QUEUE = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TRANSIENT_FAILURE = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DROP = 3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member COMPLETE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  COMPLETE = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member DROP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DROP = 3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member QUEUE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      QUEUE = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member TRANSIENT_FAILURE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TRANSIENT_FAILURE = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SubchannelAddress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SubchannelAddress = TcpSubchannelAddress | IpcSubchannelAddress;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • This represents a single backend address to connect to. This interface is a subset of net.SocketConnectOpts, i.e. the options described at https://nodejs.org/api/net.html#net_socket_connect_options_connectlistener. Those are in turn a subset of the options that can be passed to http2.connect.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Package Files (28)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Dev Dependencies (21)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@grpc/grpc-js.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@grpc/grpc-js)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <a href="https://www.jsdocs.io/package/@grpc/grpc-js"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>