@grpc/grpc-js

  • Version 1.6.7
  • Published
  • 1.46 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 | undefined) => void
                ) => void;

                  Classes

                  class CallCredentials

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

                  method compose

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

                    Parameter callCredentials

                    The other CallCredentials object.

                  method createEmpty

                  static createEmpty: () => CallCredentials;

                    method createFromGoogleCredential

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

                      Parameter googleCredentials

                      The authentication client to use. The resulting CallCredentials object.

                    method createFromMetadataGenerator

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

                      Parameter metadataGenerator

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

                    method generateMetadata

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

                      Parameter options

                      Options used in generating the Metadata object.

                    class Channel

                    class ChannelImplementation implements Channel {}

                      constructor

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

                        method close

                        close: () => void;

                          method createCall

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

                            method 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 setCredentials

                                                                    setCredentials: (credentials: CallCredentials) => void;

                                                                      method start

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

                                                                        method startRead

                                                                        startRead: () => void;

                                                                          class InterceptorConfigurationError

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

                                                                          constructor

                                                                          constructor(message: string);

                                                                            class ListenerBuilder

                                                                            class ListenerBuilder {}

                                                                              method build

                                                                              build: () => Listener;

                                                                                method withOnReceiveMessage

                                                                                withOnReceiveMessage: (onReceiveMessage: MessageListener) => this;

                                                                                  method withOnReceiveMetadata

                                                                                  withOnReceiveMetadata: (onReceiveMetadata: MetadataListener) => this;

                                                                                    method withOnReceiveStatus

                                                                                    withOnReceiveStatus: (onReceiveStatus: StatusListener) => this;

                                                                                      class Metadata

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

                                                                                      constructor

                                                                                      constructor(options?: MetadataOptions);

                                                                                        property internalRepr

                                                                                        protected internalRepr: MetadataObject;

                                                                                          method add

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

                                                                                            Parameter key

                                                                                            The key for which a new value should be appended.

                                                                                            Parameter value

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

                                                                                          method clone

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

                                                                                          method fromHttp2Headers

                                                                                          static fromHttp2Headers: (headers: 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.http_connect_creds'

                                                                                                                                                                                            'grpc.http_connect_creds'?: string;

                                                                                                                                                                                              property 'grpc.http_connect_target'

                                                                                                                                                                                              'grpc.http_connect_target'?: string;

                                                                                                                                                                                                property 'grpc.initial_reconnect_backoff_ms'

                                                                                                                                                                                                'grpc.initial_reconnect_backoff_ms'?: number;

                                                                                                                                                                                                  property 'grpc.keepalive_permit_without_calls'

                                                                                                                                                                                                  'grpc.keepalive_permit_without_calls'?: number;

                                                                                                                                                                                                    property 'grpc.keepalive_time_ms'

                                                                                                                                                                                                    'grpc.keepalive_time_ms'?: number;

                                                                                                                                                                                                      property 'grpc.keepalive_timeout_ms'

                                                                                                                                                                                                      'grpc.keepalive_timeout_ms'?: number;

                                                                                                                                                                                                        property 'grpc.max_concurrent_streams'

                                                                                                                                                                                                        'grpc.max_concurrent_streams'?: number;

                                                                                                                                                                                                          property 'grpc.max_receive_message_length'

                                                                                                                                                                                                          'grpc.max_receive_message_length'?: number;

                                                                                                                                                                                                            property 'grpc.max_reconnect_backoff_ms'

                                                                                                                                                                                                            'grpc.max_reconnect_backoff_ms'?: number;

                                                                                                                                                                                                              property 'grpc.max_send_message_length'

                                                                                                                                                                                                              'grpc.max_send_message_length'?: number;

                                                                                                                                                                                                                property 'grpc.primary_user_agent'

                                                                                                                                                                                                                'grpc.primary_user_agent'?: string;

                                                                                                                                                                                                                  property 'grpc.secondary_user_agent'

                                                                                                                                                                                                                  'grpc.secondary_user_agent'?: string;

                                                                                                                                                                                                                    property 'grpc.service_config'

                                                                                                                                                                                                                    'grpc.service_config'?: string;

                                                                                                                                                                                                                      property 'grpc.ssl_target_name_override'

                                                                                                                                                                                                                      'grpc.ssl_target_name_override'?: string;

                                                                                                                                                                                                                        property 'grpc.use_local_subchannel_pool'

                                                                                                                                                                                                                        'grpc.use_local_subchannel_pool'?: number;

                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                          [key: string]: any;

                                                                                                                                                                                                                            interface deserialize

                                                                                                                                                                                                                            interface Deserialize<T> {}

                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                              (bytes: Buffer): T;

                                                                                                                                                                                                                                interface GrpcObject

                                                                                                                                                                                                                                interface GrpcObject {}

                                                                                                                                                                                                                                  index signature

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

                                                                                                                                                                                                                                    interface Interceptor

                                                                                                                                                                                                                                    interface Interceptor {}

                                                                                                                                                                                                                                      call signature

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

                                                                                                                                                                                                                                        interface InterceptorOptions

                                                                                                                                                                                                                                        interface InterceptorOptions extends CallOptions {}

                                                                                                                                                                                                                                          property method_definition

                                                                                                                                                                                                                                          method_definition: ClientMethodDefinition<any, any>;

                                                                                                                                                                                                                                            interface InterceptorProvider

                                                                                                                                                                                                                                            interface InterceptorProvider {}

                                                                                                                                                                                                                                              call signature

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

                                                                                                                                                                                                                                                interface KeyCertPair

                                                                                                                                                                                                                                                interface KeyCertPair {}

                                                                                                                                                                                                                                                  property cert_chain

                                                                                                                                                                                                                                                  cert_chain: Buffer;

                                                                                                                                                                                                                                                    property private_key

                                                                                                                                                                                                                                                    private_key: Buffer;

                                                                                                                                                                                                                                                      interface 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 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 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 refresh

                                                                                                                                                                                                                                                                                                                                                                                                                                                      refresh: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 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 createFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    createFilter: (callStream: Call) => 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 getCredentials

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getCredentials: () => CallCredentials;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getDeadline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getDeadline: () => Deadline;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getHost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getHost: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getMethod: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getPeer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getPeer: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method halfClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        halfClose: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method sendMessageWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sendMessageWithContext: (context: MessageContext, message: 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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method receiveMessage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method receiveMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          receiveMetadata: (metadata: Metadata) => Metadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method receiveTrailers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            receiveTrailers: (status: StatusObject) => StatusObject;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method refresh

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              refresh: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method sendMessage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method sendMetadata

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface FilterFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface FilterFactory<T extends Filter> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method createFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createFilter: (callStream: Call) => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GrpcUri

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface GrpcUri {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property authority

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          authority?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property scheme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scheme?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface LoadBalancer

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method destroy

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method exitIdle

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getTypeName

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method resetBackoff

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method updateAddressList

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter addressList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The new list of addresses to connect to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter lbConfig

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface LoadBalancingConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface LoadBalancingConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getLoadBalancerName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getLoadBalancerName: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method toJsonObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toJsonObject: () => object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PickArgs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PickArgs {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property extraPickInfo

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          metadata: Metadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Picker

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method pick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            pick: (pickArgs: PickArgs) => PickResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PickResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PickResult {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property extraFilterFactories

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onCallStarted

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property pickResultType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  pickResultType: PickResultType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property status

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property subchannel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    subchannel: 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 ServiceConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ServiceConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property loadBalancingConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      loadBalancingConfig: LoadBalancingConfig[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property loadBalancingPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        loadBalancingPolicy?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property methodConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          methodConfig: MethodConfig[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => 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 (35)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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>