@grpc/grpc-js

  • Version 1.8.13
  • Published
  • 1.7 MB
  • 2 dependencies
  • 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;
createFromSecureContext: typeof ChannelCredentials.createFromSecureContext;
createFromMetadataGenerator: typeof CallCredentials.createFromMetadataGenerator;
createFromGoogleCredential: typeof CallCredentials.createFromGoogleCredential;
createEmpty: typeof CallCredentials.createEmpty;
};
  • ** Client Credentials ***

Functions

function addAdminServicesToServer

addAdminServicesToServer: (server: Server) => void;

    function closeClient

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

      Parameter client

      The client to close.

    function getChannelzHandlers

    getChannelzHandlers: () => ChannelzHandlers;

      function getChannelzServiceDefinition

      getChannelzServiceDefinition: () => ChannelzDefinition;

        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) => 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 getChannelzRef

                            getChannelzRef: () => ChannelRef;
                            • Get the channelz reference object for this channel. The returned value is garbage if channelz is disabled for this channel.

                              Returns

                            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 createFromSecureContext

                                      static createFromSecureContext: (
                                      secureContext: SecureContext,
                                      verifyOptions?: VerifyOptions
                                      ) => ChannelCredentials;
                                      • Return a new ChannelCredentials instance with credentials created using the provided secureContext. The resulting instances can be used to construct a Channel that communicates over TLS. gRPC will not override anything in the provided secureContext, so the environment variables GRPC_SSL_CIPHER_SUITES and GRPC_DEFAULT_SSL_ROOTS_FILE_PATH will not be applied.

                                        Parameter secureContext

                                        The return value of tls.createSecureContext()

                                        Parameter verifyOptions

                                        Additional options to modify certificate verification

                                      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.

                                        Parameter verifyOptions

                                        Additional options to modify certificate verification

                                      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) => Buffer,
                                            deserialize: (value: Buffer) => ResponseType,
                                            metadata: Metadata,
                                            options?: CallOptions
                                            ): ClientDuplexStream<RequestType, ResponseType>;
                                            <RequestType, ResponseType>(
                                            method: string,
                                            serialize: (value: RequestType) => Buffer,
                                            deserialize: (value: Buffer) => ResponseType,
                                            options?: CallOptions
                                            ): any;
                                            };

                                              method makeClientStreamRequest

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

                                                method makeServerStreamRequest

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

                                                  method makeUnaryRequest

                                                  makeUnaryRequest: {
                                                  <RequestType, ResponseType>(
                                                  method: string,
                                                  serialize: (value: RequestType) => Buffer,
                                                  deserialize: (value: Buffer) => ResponseType,
                                                  argument: RequestType,
                                                  metadata: Metadata,
                                                  options: CallOptions,
                                                  callback: UnaryCallback<ResponseType>
                                                  ): ClientUnaryCall;
                                                  <RequestType, ResponseType>(
                                                  method: string,
                                                  serialize: (value: RequestType) => Buffer,
                                                  deserialize: (value: Buffer) => ResponseType,
                                                  argument: RequestType,
                                                  metadata: Metadata,
                                                  callback: UnaryCallback<ResponseType>
                                                  ): any;
                                                  <RequestType, ResponseType>(
                                                  method: string,
                                                  serialize: (value: RequestType) => Buffer,
                                                  deserialize: (value: Buffer) => ResponseType,
                                                  argument: RequestType,
                                                  options: CallOptions,
                                                  callback: UnaryCallback<ResponseType>
                                                  ): any;
                                                  <RequestType, ResponseType>(
                                                  method: string,
                                                  serialize: (value: RequestType) => Buffer,
                                                  deserialize: (value: Buffer) => 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 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: http2.IncomingHttpHeaders) => 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: () => http2.OutgoingHttpHeaders;
                                                                                            • Creates an OutgoingHttpHeaders object that can be used with the http2 API.

                                                                                            method toJSON

                                                                                            toJSON: () => { [key: string]: any[] };
                                                                                            • This modifies the behavior of JSON.stringify to show an object representation of the metadata map.

                                                                                            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: () => never;

                                                                                                              method addProtoService

                                                                                                              addProtoService: () => never;

                                                                                                                method addService

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

                                                                                                                  method bind

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

                                                                                                                    method bindAsync

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

                                                                                                                      method forceShutdown

                                                                                                                      forceShutdown: () => void;

                                                                                                                        method getChannelzRef

                                                                                                                        getChannelzRef: () => ServerRef;
                                                                                                                        • Get the channelz reference object for this server. The returned value is garbage if channelz is disabled for this server.

                                                                                                                          Returns

                                                                                                                        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 getChannelzRef

                                                                                                                                                                              getChannelzRef: () => ChannelRef;
                                                                                                                                                                              • Get the channelz reference object for this channel. A request to the channelz service for the id in this object will provide information about this channel.

                                                                                                                                                                              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.default_compression_algorithm'

                                                                                                                                                                                  'grpc.default_compression_algorithm'?: CompressionAlgorithms;

                                                                                                                                                                                    property 'grpc.dns_min_time_between_resolutions_ms'

                                                                                                                                                                                    'grpc.dns_min_time_between_resolutions_ms'?: number;

                                                                                                                                                                                      property 'grpc.enable_channelz'

                                                                                                                                                                                      'grpc.enable_channelz'?: number;

                                                                                                                                                                                        property 'grpc.enable_http_proxy'

                                                                                                                                                                                        'grpc.enable_http_proxy'?: number;

                                                                                                                                                                                          property 'grpc.enable_retries'

                                                                                                                                                                                          'grpc.enable_retries'?: 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_connection_age_grace_ms'

                                                                                                                                                                                                          'grpc.max_connection_age_grace_ms'?: number;

                                                                                                                                                                                                            property 'grpc.max_connection_age_ms'

                                                                                                                                                                                                            'grpc.max_connection_age_ms'?: 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.per_rpc_retry_buffer_size'

                                                                                                                                                                                                                    'grpc.per_rpc_retry_buffer_size'?: number;

                                                                                                                                                                                                                      property 'grpc.primary_user_agent'

                                                                                                                                                                                                                      'grpc.primary_user_agent'?: string;

                                                                                                                                                                                                                        property 'grpc.retry_buffer_size'

                                                                                                                                                                                                                        'grpc.retry_buffer_size'?: number;

                                                                                                                                                                                                                          property 'grpc.secondary_user_agent'

                                                                                                                                                                                                                          'grpc.secondary_user_agent'?: string;

                                                                                                                                                                                                                            property 'grpc.service_config_disable_resolution'

                                                                                                                                                                                                                            'grpc.service_config_disable_resolution'?: number;

                                                                                                                                                                                                                              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 InterceptingListener

                                                                                                                                                                                                                                              interface InterceptingListener {}
                                                                                                                                                                                                                                              • An object with methods for handling the responses to a call.

                                                                                                                                                                                                                                              method onReceiveMessage

                                                                                                                                                                                                                                              onReceiveMessage: (message: any) => void;

                                                                                                                                                                                                                                                method onReceiveMetadata

                                                                                                                                                                                                                                                onReceiveMetadata: (metadata: Metadata) => void;

                                                                                                                                                                                                                                                  method onReceiveStatus

                                                                                                                                                                                                                                                  onReceiveStatus: (status: StatusObject) => void;

                                                                                                                                                                                                                                                    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 MetadataOptions

                                                                                                                                                                                                                                                                      interface MetadataOptions {}

                                                                                                                                                                                                                                                                        property cacheableRequest

                                                                                                                                                                                                                                                                        cacheableRequest?: boolean;

                                                                                                                                                                                                                                                                          property corked

                                                                                                                                                                                                                                                                          corked?: boolean;

                                                                                                                                                                                                                                                                            property idempotentRequest

                                                                                                                                                                                                                                                                            idempotentRequest?: boolean;

                                                                                                                                                                                                                                                                              property waitForReady

                                                                                                                                                                                                                                                                              waitForReady?: boolean;

                                                                                                                                                                                                                                                                                interface MethodDefinition

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

                                                                                                                                                                                                                                                                                  interface NextCall

                                                                                                                                                                                                                                                                                  interface NextCall {}

                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                    (options: InterceptorOptions): InterceptingCallInterface;

                                                                                                                                                                                                                                                                                      interface ProtobufTypeDefinition

                                                                                                                                                                                                                                                                                      interface ProtobufTypeDefinition {}

                                                                                                                                                                                                                                                                                        property fileDescriptorProtos

                                                                                                                                                                                                                                                                                        fileDescriptorProtos: Buffer[];

                                                                                                                                                                                                                                                                                          property format

                                                                                                                                                                                                                                                                                          format: string;

                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                            type: object;

                                                                                                                                                                                                                                                                                              interface requestCallback

                                                                                                                                                                                                                                                                                              interface UnaryCallback<ResponseType> {}

                                                                                                                                                                                                                                                                                                call signature

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

                                                                                                                                                                                                                                                                                                  interface serialize

                                                                                                                                                                                                                                                                                                  interface Serialize<T> {}

                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                    (value: T): Buffer;

                                                                                                                                                                                                                                                                                                      interface ServiceClientConstructor

                                                                                                                                                                                                                                                                                                      interface ServiceClientConstructor {}

                                                                                                                                                                                                                                                                                                        property service

                                                                                                                                                                                                                                                                                                        service: ServiceDefinition;

                                                                                                                                                                                                                                                                                                          property serviceName

                                                                                                                                                                                                                                                                                                          serviceName: string;

                                                                                                                                                                                                                                                                                                            construct signature

                                                                                                                                                                                                                                                                                                            new (
                                                                                                                                                                                                                                                                                                            address: string,
                                                                                                                                                                                                                                                                                                            credentials: ChannelCredentials,
                                                                                                                                                                                                                                                                                                            options?: Partial<ChannelOptions>
                                                                                                                                                                                                                                                                                                            ): ServiceClient;

                                                                                                                                                                                                                                                                                                              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 compressionAlgorithms

                                                                                                                                                                                                                                                                                                                          enum compressionAlgorithms {
                                                                                                                                                                                                                                                                                                                          identity = 0,
                                                                                                                                                                                                                                                                                                                          deflate = 1,
                                                                                                                                                                                                                                                                                                                          gzip = 2,
                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                            member deflate

                                                                                                                                                                                                                                                                                                                            deflate = 1

                                                                                                                                                                                                                                                                                                                              member gzip

                                                                                                                                                                                                                                                                                                                              gzip = 2

                                                                                                                                                                                                                                                                                                                                member identity

                                                                                                                                                                                                                                                                                                                                identity = 0

                                                                                                                                                                                                                                                                                                                                  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,
                                                                                                                                                                                                                                                                                                                                              NONE = 3,
                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                member DEBUG

                                                                                                                                                                                                                                                                                                                                                DEBUG = 0

                                                                                                                                                                                                                                                                                                                                                  member ERROR

                                                                                                                                                                                                                                                                                                                                                  ERROR = 2

                                                                                                                                                                                                                                                                                                                                                    member INFO

                                                                                                                                                                                                                                                                                                                                                    INFO = 1

                                                                                                                                                                                                                                                                                                                                                      member NONE

                                                                                                                                                                                                                                                                                                                                                      NONE = 3

                                                                                                                                                                                                                                                                                                                                                        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 ServerErrorResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                type ServerErrorResponse = ServerStatusResponse & Error;

                                                                                                                                                                                                                                                                                                                                                                                                                                  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 createChildChannelControlHelper

                                                                                                                                                                                                                                                                                                                                                                                                                                              createChildChannelControlHelper: (
                                                                                                                                                                                                                                                                                                                                                                                                                                              parent: ChannelControlHelper,
                                                                                                                                                                                                                                                                                                                                                                                                                                              overrides: Partial<ChannelControlHelper>
                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => ChannelControlHelper;
                                                                                                                                                                                                                                                                                                                                                                                                                                              • Create a child ChannelControlHelper that overrides some methods of the parent while letting others pass through to the parent unmodified. This allows other code to create these children without needing to know about all of the methods to be passed through.

                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter parent

                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter overrides

                                                                                                                                                                                                                                                                                                                                                                                                                                              function durationToMs

                                                                                                                                                                                                                                                                                                                                                                                                                                              durationToMs: (duration: Duration) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                function getFirstUsableConfig

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                  function log

                                                                                                                                                                                                                                                                                                                                                                                                                                                  log: (severity: LogVerbosity, ...args: any[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    function registerAdminService

                                                                                                                                                                                                                                                                                                                                                                                                                                                    registerAdminService: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                    getServiceDefinition: GetServiceDefinition,
                                                                                                                                                                                                                                                                                                                                                                                                                                                    getHandlers: GetHandlers
                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Check whether the timer is currently running.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method ref

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ref: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Set that while the timer is running, it should keep the Node process running.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method reset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reset: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Reset the delay time to its initial value. If the timer is still running, retroactively apply that reset to the current timer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Set that while the timer is running, it should not keep the Node process running.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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 BaseSubchannelWrapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                abstract class BaseSubchannelWrapper implements SubchannelInterface {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(child: SubchannelInterface);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property child

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected child: SubchannelInterface;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method addConnectivityStateListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      addConnectivityStateListener: (listener: ConnectivityStateListener) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getAddress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getAddress: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getChannelzRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getChannelzRef: () => SubchannelRef;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getConnectivityState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getConnectivityState: () => ConnectivityState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getRealSubchannel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getRealSubchannel: () => Subchannel;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method ref

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ref: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method removeConnectivityStateListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  removeConnectivityStateListener: (listener: ConnectivityStateListener) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method startConnecting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    startConnecting: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method throttleKeepalive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      throttleKeepalive: (newKeepaliveTime: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method unref

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        unref: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 clone

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          clone: () => FilterStackFactory;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method createFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            createFilter: () => FilterStack;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method push

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              push: (filterFactories: FilterFactory<Filter>[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class OutlierDetectionLoadBalancingConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class OutlierDetectionLoadBalancingConfig implements LoadBalancingConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  intervalMs: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  baseEjectionTimeMs: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  maxEjectionTimeMs: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  maxEjectionPercent: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  successRateEjection: Partial<SuccessRateEjectionConfig>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  failurePercentageEjection: Partial<FailurePercentageEjectionConfig>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  childPolicy: LoadBalancingConfig[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method copyWithChildPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    copyWithChildPolicy: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    childPolicy: LoadBalancingConfig[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => OutlierDetectionLoadBalancingConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method createFromJson

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static createFromJson: (obj: any) => OutlierDetectionLoadBalancingConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getBaseEjectionTimeMs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getBaseEjectionTimeMs: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getChildPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getChildPolicy: () => LoadBalancingConfig[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getFailurePercentageEjectionConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getFailurePercentageEjectionConfig: () => FailurePercentageEjectionConfig | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getIntervalMs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getIntervalMs: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getLoadBalancerName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getLoadBalancerName: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getMaxEjectionPercent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getMaxEjectionPercent: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getMaxEjectionTimeMs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getMaxEjectionTimeMs: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getSuccessRateEjectionConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getSuccessRateEjectionConfig: () => SuccessRateEjectionConfig | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method toJsonObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        toJsonObject: () => object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 getCallNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getCallNumber: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getPeer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getPeer: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method halfClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          halfClose: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method sendMessageWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sendMessageWithContext: (context: MessageContext, message: Buffer) => 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 addChannelzChild

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    addChannelzChild: (child: ChannelRef | SubchannelRef) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method createSubchannel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createSubchannel: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      subchannelAddress: SubchannelAddress,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      subchannelArgs: ChannelOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => SubchannelInterface;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 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 removeChannelzChild

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      removeChannelzChild: (child: ChannelRef | SubchannelRef) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 Duration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Duration {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property nanos

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            nanos: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property seconds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              seconds: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface FailurePercentageEjectionConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface FailurePercentageEjectionConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property enforcement_percentage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly enforcement_percentage: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property minimum_hosts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly minimum_hosts: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property request_volume

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly request_volume: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property threshold

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly threshold: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Filter {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Filter classes represent related per-call logic and state that is primarily used to modify incoming and outgoing data. All async filters can be rejected. The rejection error must be a StatusObject, and a rejection will cause the call to end with that status.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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: () => 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 MethodConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MethodConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property hedgingPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hedgingPolicy?: HedgingPolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property maxRequestBytes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          maxRequestBytes?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property maxResponseBytes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            maxResponseBytes?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: MethodConfigName[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property retryPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                retryPolicy?: RetryPolicy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  timeout?: Duration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property waitForReady

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    waitForReady?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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 onCallEnded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onCallEnded: ((statusCode: Status) => void) | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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: SubchannelInterface | 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 RetryPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface RetryPolicy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property backoffMultiplier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        backoffMultiplier: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property initialBackoff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          initialBackoff: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property maxAttempts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            maxAttempts: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property maxBackoff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              maxBackoff: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property retryableStatusCodes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                retryableStatusCodes: (Status | string)[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ServiceConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ServiceConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property loadBalancingConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    loadBalancingConfig: LoadBalancingConfig[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property loadBalancingPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      loadBalancingPolicy?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property methodConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        methodConfig: MethodConfig[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property retryThrottling

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          retryThrottling?: RetryThrottling;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SubchannelInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SubchannelInterface {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • This is an interface for load balancing policies to use to interact with subchannels. This allows load balancing policies to wrap and unwrap subchannels.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Any load balancing policy that wraps subchannels must unwrap the subchannel in the picker, so that other load balancing policies consistently have access to their own wrapper objects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method addConnectivityStateListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            addConnectivityStateListener: (listener: ConnectivityStateListener) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getAddress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getAddress: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getChannelzRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getChannelzRef: () => SubchannelRef;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getConnectivityState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getConnectivityState: () => ConnectivityState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getRealSubchannel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getRealSubchannel: () => Subchannel;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • If this is a wrapper, return the wrapped subchannel, otherwise return this

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method ref

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ref: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method removeConnectivityStateListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      removeConnectivityStateListener: (listener: ConnectivityStateListener) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method startConnecting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        startConnecting: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method throttleKeepalive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          throttleKeepalive: (newKeepaliveTime: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method unref

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            unref: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SuccessRateEjectionConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SuccessRateEjectionConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property enforcement_percentage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly enforcement_percentage: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property minimum_hosts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly minimum_hosts: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property request_volume

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly request_volume: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property stdev_factor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly stdev_factor: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 ConnectivityStateListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ConnectivityStateListener = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  subchannel: SubchannelInterface,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  previousState: ConnectivityState,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  newState: ConnectivityState,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  keepaliveTime: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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 (36)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dependencies (2)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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>