@grpc/grpc-js

  • Version 1.7.3
  • Published
  • 1.65 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 log

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

                                                                                                                                                                                                                                                                                                                                                                                                                                function registerAdminService

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

                                                                                                                                                                                                                                                                                                                                                                                                                                  function registerLoadBalancerType

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

                                                                                                                                                                                                                                                                                                                                                                                                                                    function registerResolver

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

                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter prefix

                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter resolverClass

                                                                                                                                                                                                                                                                                                                                                                                                                                    function subchannelAddressToString

                                                                                                                                                                                                                                                                                                                                                                                                                                    subchannelAddressToString: (address: SubchannelAddress) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                      function trace

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

                                                                                                                                                                                                                                                                                                                                                                                                                                        function uriToString

                                                                                                                                                                                                                                                                                                                                                                                                                                        uriToString: (uri: GrpcUri) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                          function validateLoadBalancingConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                          validateLoadBalancingConfig: (obj: any) => LoadBalancingConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                                            class BackoffTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                            class BackoffTimeout {}

                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                method isRunning

                                                                                                                                                                                                                                                                                                                                                                                                                                                isRunning: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                • Check whether the timer is currently running.

                                                                                                                                                                                                                                                                                                                                                                                                                                                method ref

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                method reset

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                method runOnce

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                method stop

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                method unref

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                class BaseFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                abstract class BaseFilter implements Filter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method receiveMessage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method receiveMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                    receiveMetadata: (metadata: Metadata) => Metadata;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method receiveTrailers

                                                                                                                                                                                                                                                                                                                                                                                                                                                      receiveTrailers: (status: StatusObject) => StatusObject;

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