@nestjs/microservices

  • Version 7.6.17
  • Published
  • 336 kB
  • 3 dependencies
  • MIT license

Install

npm i @nestjs/microservices
yarn add @nestjs/microservices
pnpm add @nestjs/microservices

Overview

Nest - modern, fast, powerful node.js web framework (@microservices)

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Variables

variable CONTEXT

const CONTEXT: string;

    variable GrpcService

    const GrpcService: any;
    • Defines the GrpcService. The service can inject dependencies through constructor. Those dependencies have to belong to the same module.

    Functions

    function Client

    Client: (metadata?: ClientOptions) => PropertyDecorator;
    • Attaches the ClientProxy instance to the given property

      Parameter metadata

      optional client metadata

    function createGrpcMethodMetadata

    createGrpcMethodMetadata: (
    target: object,
    key: string | symbol,
    service: string | undefined,
    method: string | undefined,
    streaming?: GrpcMethodStreamingType
    ) => { service: string; rpc: string; streaming: GrpcMethodStreamingType };

      function Ctx

      Ctx: () => ParameterDecorator;

        function EventPattern

        EventPattern: <T = string>(
        metadata?: T,
        transport?: Transport
        ) => MethodDecorator;
        • Subscribes to incoming events which fulfils chosen pattern.

        function GrpcMethod

        GrpcMethod: {
        (service?: string): MethodDecorator;
        (service: string, method?: string): MethodDecorator;
        };
        • Registers gRPC method handler for specified service.

        function GrpcStreamCall

        GrpcStreamCall: {
        (service?: string): MethodDecorator;
        (service: string, method?: string): MethodDecorator;
        };
        • Registers gRPC call pass through handler for service and method

          Parameter service

          String parameter reflecting the name of service definition from proto file

        • Parameter service

          String parameter reflecting the name of service definition from proto file

          Parameter method

          Optional string parameter reflecting the name of method inside of a service definition coming after rpc keyword

        function GrpcStreamMethod

        GrpcStreamMethod: {
        (service?: string): MethodDecorator;
        (service: string, method?: string): MethodDecorator;
        };
        • Registers gRPC call through RX handler for service and method

          Parameter service

          String parameter reflecting the name of service definition from proto file

        • Parameter service

          String parameter reflecting the name of service definition from proto file

          Parameter method

          Optional string parameter reflecting the name of method inside of a service definition coming after rpc keyword

        function KafkaLogger

        KafkaLogger: (
        logger: any
        ) => ({
        namespace,
        level,
        label,
        log,
        }: {
        namespace: any;
        level: any;
        label: any;
        log: any;
        }) => void;

          function MessagePattern

          MessagePattern: <T = string | PatternMetadata>(
          metadata?: T,
          transport?: Transport
          ) => MethodDecorator;
          • Subscribes to incoming messages which fulfils chosen pattern.

          function Payload

          Payload: { (): ParameterDecorator; (...pipes: any[]): ParameterDecorator };

            Classes

            class BaseRpcExceptionFilter

            class BaseRpcExceptionFilter<T = any, R = any> implements RpcExceptionFilter<T> {}

              method catch

              catch: (exception: T, host: any) => any;

                method handleUnknownError

                handleUnknownError: (exception: T, status: string) => any;

                  method isError

                  isError: (exception: any) => exception is Error;

                    class ClientGrpcProxy

                    class ClientGrpcProxy extends ClientProxy implements ClientGrpc {}

                      constructor

                      constructor(options: {
                      url?: string;
                      maxSendMessageLength?: number;
                      maxReceiveMessageLength?: number;
                      maxMetadataSize?: number;
                      keepalive?: {
                      keepaliveTimeMs?: number;
                      keepaliveTimeoutMs?: number;
                      keepalivePermitWithoutCalls?: number;
                      http2MaxPingsWithoutData?: number;
                      http2MinTimeBetweenPingsMs?: number;
                      http2MinPingIntervalWithoutDataMs?: number;
                      http2MaxPingStrikes?: number;
                      };
                      channelOptions?: ChannelOptions;
                      credentials?: any;
                      protoPath: string | string[];
                      package: string | string[];
                      protoLoader?: string;
                      loader?: {
                      keepCase?: boolean;
                      alternateCommentMode?: boolean;
                      longs?: Function;
                      enums?: Function;
                      bytes?: Function;
                      defaults?: boolean;
                      arrays?: boolean;
                      objects?: boolean;
                      oneofs?: boolean;
                      json?: boolean;
                      includeDirs?: string[];
                      };
                      });

                        property clients

                        protected readonly clients: Map<string, any>;

                          property grpcClients

                          protected grpcClients: any[];

                            property logger

                            protected readonly logger: any;

                              property options

                              protected readonly options: {
                              url?: string;
                              maxSendMessageLength?: number;
                              maxReceiveMessageLength?: number;
                              maxMetadataSize?: number;
                              keepalive?: {
                              keepaliveTimeMs?: number;
                              keepaliveTimeoutMs?: number;
                              keepalivePermitWithoutCalls?: number;
                              http2MaxPingsWithoutData?: number;
                              http2MinTimeBetweenPingsMs?: number;
                              http2MinPingIntervalWithoutDataMs?: number;
                              http2MaxPingStrikes?: number;
                              };
                              channelOptions?: ChannelOptions;
                              credentials?: any;
                              protoPath: string | string[];
                              package: string | string[];
                              protoLoader?: string;
                              loader?: {
                              keepCase?: boolean;
                              alternateCommentMode?: boolean;
                              longs?: Function;
                              enums?: Function;
                              bytes?: Function;
                              defaults?: boolean;
                              arrays?: boolean;
                              objects?: boolean;
                              oneofs?: boolean;
                              json?: boolean;
                              includeDirs?: string[];
                              };
                              };

                                property url

                                protected readonly url: string;

                                  method close

                                  close: () => void;

                                    method connect

                                    connect: () => Promise<any>;

                                      method createClientByServiceName

                                      createClientByServiceName: (name: string) => any;

                                        method createClients

                                        createClients: () => any[];

                                          method createServiceMethod

                                          createServiceMethod: (
                                          client: any,
                                          methodName: string
                                          ) => (...args: unknown[]) => any;

                                            method createStreamServiceMethod

                                            createStreamServiceMethod: (
                                            client: unknown,
                                            methodName: string
                                            ) => (...args: any[]) => any;

                                              method createUnaryServiceMethod

                                              createUnaryServiceMethod: (
                                              client: any,
                                              methodName: string
                                              ) => (...args: any[]) => any;

                                                method dispatchEvent

                                                protected dispatchEvent: (packet: any) => Promise<any>;

                                                  method getClient

                                                  protected getClient: (name: string) => any;

                                                    method getClientByServiceName

                                                    getClientByServiceName: <T = unknown>(name: string) => T;

                                                      method getKeepaliveOptions

                                                      getKeepaliveOptions: () => {};

                                                        method getService

                                                        getService: <T extends {}>(name: string) => T;

                                                          method loadProto

                                                          loadProto: () => any;

                                                            method lookupPackage

                                                            lookupPackage: (root: any, packageName: string) => any;

                                                              method publish

                                                              protected publish: (packet: any, callback: (packet: any) => any) => any;

                                                                method send

                                                                send: <TResult = any, TInput = any>(pattern: any, data: TInput) => any;

                                                                  class ClientKafka

                                                                  class ClientKafka extends ClientProxy {}

                                                                    constructor

                                                                    constructor(options: {
                                                                    postfixId?: string;
                                                                    client?: KafkaConfig;
                                                                    consumer?: ConsumerConfig;
                                                                    run?: Omit<ConsumerRunConfig, 'eachBatch' | 'eachMessage'>;
                                                                    subscribe?: Omit<ConsumerSubscribeTopic, 'topic'>;
                                                                    producer?: ProducerConfig;
                                                                    send?: Omit<ProducerRecord, 'topic' | 'messages'>;
                                                                    serializer?: Serializer<any, any>;
                                                                    deserializer?: Deserializer<any, any>;
                                                                    });

                                                                      property brokers

                                                                      protected brokers: string[] | BrokersFunction;

                                                                        property client

                                                                        protected client: Kafka;

                                                                          property clientId

                                                                          protected clientId: string;

                                                                            property consumer

                                                                            protected consumer: Consumer;

                                                                              property consumerAssignments

                                                                              protected consumerAssignments: { [key: string]: number };

                                                                                property groupId

                                                                                protected groupId: string;

                                                                                  property logger

                                                                                  protected logger: any;

                                                                                    property options

                                                                                    protected readonly options: {
                                                                                    postfixId?: string;
                                                                                    client?: KafkaConfig;
                                                                                    consumer?: ConsumerConfig;
                                                                                    run?: Omit<ConsumerRunConfig, 'eachBatch' | 'eachMessage'>;
                                                                                    subscribe?: Omit<ConsumerSubscribeTopic, 'topic'>;
                                                                                    producer?: ProducerConfig;
                                                                                    send?: Omit<ProducerRecord, 'topic' | 'messages'>;
                                                                                    serializer?: Serializer<any, any>;
                                                                                    deserializer?: Deserializer<any, any>;
                                                                                    };

                                                                                      property producer

                                                                                      protected producer: Producer;

                                                                                        property responsePatterns

                                                                                        protected responsePatterns: string[];

                                                                                          method bindTopics

                                                                                          bindTopics: () => Promise<void>;

                                                                                            method close

                                                                                            close: () => Promise<void>;

                                                                                              method connect

                                                                                              connect: () => Promise<Producer>;

                                                                                                method createClient

                                                                                                createClient: <T = any>() => T;

                                                                                                  method createResponseCallback

                                                                                                  createResponseCallback: () => (payload: EachMessagePayload) => any;

                                                                                                    method dispatchEvent

                                                                                                    protected dispatchEvent: (packet: OutgoingEvent) => Promise<any>;

                                                                                                      method getConsumerAssignments

                                                                                                      getConsumerAssignments: () => { [key: string]: number };

                                                                                                        method getReplyTopicPartition

                                                                                                        protected getReplyTopicPartition: (topic: string) => string;

                                                                                                          method getResponsePatternName

                                                                                                          protected getResponsePatternName: (pattern: string) => string;

                                                                                                            method initializeDeserializer

                                                                                                            protected initializeDeserializer: (options: KafkaOptions['options']) => void;

                                                                                                              method initializeSerializer

                                                                                                              protected initializeSerializer: (options: KafkaOptions['options']) => void;

                                                                                                                method publish

                                                                                                                protected publish: (
                                                                                                                partialPacket: ReadPacket,
                                                                                                                callback: (packet: WritePacket) => any
                                                                                                                ) => Function;

                                                                                                                  method setConsumerAssignments

                                                                                                                  protected setConsumerAssignments: (data: ConsumerGroupJoinEvent) => void;

                                                                                                                    method subscribeToResponseOf

                                                                                                                    subscribeToResponseOf: (pattern: any) => void;

                                                                                                                      class ClientMqtt

                                                                                                                      class ClientMqtt extends ClientProxy {}

                                                                                                                        constructor

                                                                                                                        constructor(
                                                                                                                        options: MqttClientOptions & {
                                                                                                                        url?: string;
                                                                                                                        serializer?: Serializer<any, any>;
                                                                                                                        deserializer?: Deserializer<any, any>;
                                                                                                                        }
                                                                                                                        );

                                                                                                                          property connection

                                                                                                                          protected connection: Promise<any>;

                                                                                                                            property logger

                                                                                                                            protected readonly logger: any;

                                                                                                                              property mqttClient

                                                                                                                              protected mqttClient: MqttClient;

                                                                                                                                property options

                                                                                                                                protected readonly options: MqttClientOptions & {
                                                                                                                                url?: string;
                                                                                                                                serializer?: Serializer<any, any>;
                                                                                                                                deserializer?: Deserializer<any, any>;
                                                                                                                                };

                                                                                                                                  property subscriptionsCount

                                                                                                                                  protected readonly subscriptionsCount: Map<string, number>;

                                                                                                                                    property url

                                                                                                                                    protected readonly url: string;

                                                                                                                                      method close

                                                                                                                                      close: () => void;

                                                                                                                                        method connect

                                                                                                                                        connect: () => Promise<any>;

                                                                                                                                          method createClient

                                                                                                                                          createClient: () => MqttClient;

                                                                                                                                            method createResponseCallback

                                                                                                                                            createResponseCallback: () => (channel: string, buffer: any) => any;

                                                                                                                                              method dispatchEvent

                                                                                                                                              protected dispatchEvent: (packet: ReadPacket) => Promise<any>;

                                                                                                                                                method getRequestPattern

                                                                                                                                                getRequestPattern: (pattern: string) => string;

                                                                                                                                                  method getResponsePattern

                                                                                                                                                  getResponsePattern: (pattern: string) => string;

                                                                                                                                                    method handleError

                                                                                                                                                    handleError: (client: MqttClient) => void;

                                                                                                                                                      method mergeCloseEvent

                                                                                                                                                      mergeCloseEvent: <T = any>(instance: MqttClient, source$: any) => any;

                                                                                                                                                        method publish

                                                                                                                                                        protected publish: (
                                                                                                                                                        partialPacket: ReadPacket,
                                                                                                                                                        callback: (packet: WritePacket) => any
                                                                                                                                                        ) => Function;

                                                                                                                                                          method unsubscribeFromChannel

                                                                                                                                                          protected unsubscribeFromChannel: (channel: string) => void;

                                                                                                                                                            class ClientNats

                                                                                                                                                            class ClientNats extends ClientProxy {}

                                                                                                                                                              constructor

                                                                                                                                                              constructor(options: {
                                                                                                                                                              [key: string]: any;
                                                                                                                                                              encoding?: string;
                                                                                                                                                              url?: string;
                                                                                                                                                              name?: string;
                                                                                                                                                              user?: string;
                                                                                                                                                              pass?: string;
                                                                                                                                                              maxPingOut?: number;
                                                                                                                                                              maxReconnectAttempts?: number;
                                                                                                                                                              reconnectTimeWait?: number;
                                                                                                                                                              reconnectJitter?: number;
                                                                                                                                                              reconnectJitterTLS?: number;
                                                                                                                                                              reconnectDelayHandler?: any;
                                                                                                                                                              servers?: string[];
                                                                                                                                                              nkey?: any;
                                                                                                                                                              reconnect?: boolean;
                                                                                                                                                              pedantic?: boolean;
                                                                                                                                                              tls?: any;
                                                                                                                                                              queue?: string;
                                                                                                                                                              serializer?: Serializer<any, any>;
                                                                                                                                                              deserializer?: Deserializer<any, any>;
                                                                                                                                                              userJWT?: string;
                                                                                                                                                              nonceSigner?: any;
                                                                                                                                                              userCreds?: any;
                                                                                                                                                              useOldRequestStyle?: boolean;
                                                                                                                                                              pingInterval?: number;
                                                                                                                                                              preserveBuffers?: boolean;
                                                                                                                                                              waitOnFirstConnect?: boolean;
                                                                                                                                                              verbose?: boolean;
                                                                                                                                                              noEcho?: boolean;
                                                                                                                                                              noRandomize?: boolean;
                                                                                                                                                              timeout?: number;
                                                                                                                                                              token?: string;
                                                                                                                                                              yieldTime?: number;
                                                                                                                                                              tokenHandler?: any;
                                                                                                                                                              });

                                                                                                                                                                property connection

                                                                                                                                                                protected connection: Promise<any>;

                                                                                                                                                                  property logger

                                                                                                                                                                  protected readonly logger: any;

                                                                                                                                                                    property natsClient

                                                                                                                                                                    protected natsClient: Client;

                                                                                                                                                                      property options

                                                                                                                                                                      protected readonly options: {
                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                      encoding?: string;
                                                                                                                                                                      url?: string;
                                                                                                                                                                      name?: string;
                                                                                                                                                                      user?: string;
                                                                                                                                                                      pass?: string;
                                                                                                                                                                      maxPingOut?: number;
                                                                                                                                                                      maxReconnectAttempts?: number;
                                                                                                                                                                      reconnectTimeWait?: number;
                                                                                                                                                                      reconnectJitter?: number;
                                                                                                                                                                      reconnectJitterTLS?: number;
                                                                                                                                                                      reconnectDelayHandler?: any;
                                                                                                                                                                      servers?: string[];
                                                                                                                                                                      nkey?: any;
                                                                                                                                                                      reconnect?: boolean;
                                                                                                                                                                      pedantic?: boolean;
                                                                                                                                                                      tls?: any;
                                                                                                                                                                      queue?: string;
                                                                                                                                                                      serializer?: Serializer<any, any>;
                                                                                                                                                                      deserializer?: Deserializer<any, any>;
                                                                                                                                                                      userJWT?: string;
                                                                                                                                                                      nonceSigner?: any;
                                                                                                                                                                      userCreds?: any;
                                                                                                                                                                      useOldRequestStyle?: boolean;
                                                                                                                                                                      pingInterval?: number;
                                                                                                                                                                      preserveBuffers?: boolean;
                                                                                                                                                                      waitOnFirstConnect?: boolean;
                                                                                                                                                                      verbose?: boolean;
                                                                                                                                                                      noEcho?: boolean;
                                                                                                                                                                      noRandomize?: boolean;
                                                                                                                                                                      timeout?: number;
                                                                                                                                                                      token?: string;
                                                                                                                                                                      yieldTime?: number;
                                                                                                                                                                      tokenHandler?: any;
                                                                                                                                                                      };

                                                                                                                                                                        property url

                                                                                                                                                                        protected readonly url: string;

                                                                                                                                                                          method close

                                                                                                                                                                          close: () => void;

                                                                                                                                                                            method connect

                                                                                                                                                                            connect: () => Promise<any>;

                                                                                                                                                                              method createClient

                                                                                                                                                                              createClient: () => Client;

                                                                                                                                                                                method createSubscriptionHandler

                                                                                                                                                                                createSubscriptionHandler: (
                                                                                                                                                                                packet: ReadPacket & PacketId,
                                                                                                                                                                                callback: (packet: WritePacket) => any
                                                                                                                                                                                ) => Function;

                                                                                                                                                                                  method dispatchEvent

                                                                                                                                                                                  protected dispatchEvent: (packet: ReadPacket) => Promise<any>;

                                                                                                                                                                                    method handleError

                                                                                                                                                                                    handleError: (client: Client) => void;

                                                                                                                                                                                      method publish

                                                                                                                                                                                      protected publish: (
                                                                                                                                                                                      partialPacket: ReadPacket,
                                                                                                                                                                                      callback: (packet: WritePacket) => any
                                                                                                                                                                                      ) => Function;

                                                                                                                                                                                        class ClientProxy

                                                                                                                                                                                        abstract class ClientProxy {}

                                                                                                                                                                                          property deserializer

                                                                                                                                                                                          protected deserializer: ProducerDeserializer;

                                                                                                                                                                                            property routingMap

                                                                                                                                                                                            protected routingMap: Map<string, Function>;

                                                                                                                                                                                              property serializer

                                                                                                                                                                                              protected serializer: ProducerSerializer;

                                                                                                                                                                                                method assignPacketId

                                                                                                                                                                                                protected assignPacketId: (packet: ReadPacket) => ReadPacket & PacketId;

                                                                                                                                                                                                  method close

                                                                                                                                                                                                  abstract close: () => any;

                                                                                                                                                                                                    method connect

                                                                                                                                                                                                    abstract connect: () => Promise<any>;

                                                                                                                                                                                                      method connect$

                                                                                                                                                                                                      protected connect$: (
                                                                                                                                                                                                      instance: any,
                                                                                                                                                                                                      errorEvent?: string,
                                                                                                                                                                                                      connectEvent?: string
                                                                                                                                                                                                      ) => any;

                                                                                                                                                                                                        method createObserver

                                                                                                                                                                                                        protected createObserver: <T>(observer: any) => (packet: WritePacket) => void;

                                                                                                                                                                                                          method dispatchEvent

                                                                                                                                                                                                          protected abstract dispatchEvent: <T = any>(packet: ReadPacket) => Promise<T>;

                                                                                                                                                                                                            method emit

                                                                                                                                                                                                            emit: <TResult = any, TInput = any>(pattern: any, data: TInput) => any;

                                                                                                                                                                                                              method getOptionsProp

                                                                                                                                                                                                              protected getOptionsProp: <
                                                                                                                                                                                                              T extends
                                                                                                                                                                                                              | {
                                                                                                                                                                                                              url?: string;
                                                                                                                                                                                                              maxSendMessageLength?: number;
                                                                                                                                                                                                              maxReceiveMessageLength?: number;
                                                                                                                                                                                                              maxMetadataSize?: number;
                                                                                                                                                                                                              keepalive?: {
                                                                                                                                                                                                              keepaliveTimeMs?: number;
                                                                                                                                                                                                              keepaliveTimeoutMs?: number;
                                                                                                                                                                                                              keepalivePermitWithoutCalls?: number;
                                                                                                                                                                                                              http2MaxPingsWithoutData?: number;
                                                                                                                                                                                                              http2MinTimeBetweenPingsMs?: number;
                                                                                                                                                                                                              http2MinPingIntervalWithoutDataMs?: number;
                                                                                                                                                                                                              http2MaxPingStrikes?: number;
                                                                                                                                                                                                              };
                                                                                                                                                                                                              channelOptions?: ChannelOptions;
                                                                                                                                                                                                              credentials?: any;
                                                                                                                                                                                                              protoPath: string | string[];
                                                                                                                                                                                                              package: string | string[];
                                                                                                                                                                                                              protoLoader?: string;
                                                                                                                                                                                                              loader?: {
                                                                                                                                                                                                              keepCase?: boolean;
                                                                                                                                                                                                              alternateCommentMode?: boolean;
                                                                                                                                                                                                              longs?: Function;
                                                                                                                                                                                                              enums?: Function;
                                                                                                                                                                                                              bytes?: Function;
                                                                                                                                                                                                              defaults?: boolean;
                                                                                                                                                                                                              arrays?: boolean;
                                                                                                                                                                                                              objects?: boolean;
                                                                                                                                                                                                              oneofs?: boolean;
                                                                                                                                                                                                              json?: boolean;
                                                                                                                                                                                                              includeDirs?: string[];
                                                                                                                                                                                                              };
                                                                                                                                                                                                              }
                                                                                                                                                                                                              | {
                                                                                                                                                                                                              postfixId?: string;
                                                                                                                                                                                                              client?: KafkaConfig;
                                                                                                                                                                                                              consumer?: ConsumerConfig;
                                                                                                                                                                                                              run?: Omit<ConsumerRunConfig, 'eachBatch' | 'eachMessage'>;
                                                                                                                                                                                                              subscribe?: Omit<ConsumerSubscribeTopic, 'topic'>;
                                                                                                                                                                                                              producer?: ProducerConfig;
                                                                                                                                                                                                              send?: Omit<ProducerRecord, 'topic' | 'messages'>;
                                                                                                                                                                                                              serializer?: Serializer<any, any>;
                                                                                                                                                                                                              deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                              }
                                                                                                                                                                                                              | (MqttClientOptions & {
                                                                                                                                                                                                              url?: string;
                                                                                                                                                                                                              serializer?: Serializer<any, any>;
                                                                                                                                                                                                              deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                              })
                                                                                                                                                                                                              | {
                                                                                                                                                                                                              [key: string]: any;
                                                                                                                                                                                                              encoding?: string;
                                                                                                                                                                                                              url?: string;
                                                                                                                                                                                                              name?: string;
                                                                                                                                                                                                              user?: string;
                                                                                                                                                                                                              pass?: string;
                                                                                                                                                                                                              maxPingOut?: number;
                                                                                                                                                                                                              maxReconnectAttempts?: number;
                                                                                                                                                                                                              reconnectTimeWait?: number;
                                                                                                                                                                                                              reconnectJitter?: number;
                                                                                                                                                                                                              reconnectJitterTLS?: number;
                                                                                                                                                                                                              reconnectDelayHandler?: any;
                                                                                                                                                                                                              servers?: string[];
                                                                                                                                                                                                              nkey?: any;
                                                                                                                                                                                                              reconnect?: boolean;
                                                                                                                                                                                                              pedantic?: boolean;
                                                                                                                                                                                                              tls?: any;
                                                                                                                                                                                                              queue?: string;
                                                                                                                                                                                                              serializer?: Serializer<any, any>;
                                                                                                                                                                                                              deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                              userJWT?: string;
                                                                                                                                                                                                              nonceSigner?: any;
                                                                                                                                                                                                              userCreds?: any;
                                                                                                                                                                                                              useOldRequestStyle?: boolean;
                                                                                                                                                                                                              pingInterval?: number;
                                                                                                                                                                                                              preserveBuffers?: boolean;
                                                                                                                                                                                                              waitOnFirstConnect?: boolean;
                                                                                                                                                                                                              verbose?: boolean;
                                                                                                                                                                                                              noEcho?: boolean;
                                                                                                                                                                                                              noRandomize?: boolean;
                                                                                                                                                                                                              timeout?: number;
                                                                                                                                                                                                              token?: string;
                                                                                                                                                                                                              yieldTime?: number;
                                                                                                                                                                                                              tokenHandler?: any;
                                                                                                                                                                                                              }
                                                                                                                                                                                                              | ({
                                                                                                                                                                                                              url?: string;
                                                                                                                                                                                                              retryAttempts?: number;
                                                                                                                                                                                                              retryDelay?: number;
                                                                                                                                                                                                              serializer?: Serializer<any, any>;
                                                                                                                                                                                                              deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                              } & ClientOpts)
                                                                                                                                                                                                              | {
                                                                                                                                                                                                              host?: string;
                                                                                                                                                                                                              port?: number;
                                                                                                                                                                                                              serializer?: Serializer<any, any>;
                                                                                                                                                                                                              deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                              }
                                                                                                                                                                                                              | {
                                                                                                                                                                                                              urls?: string[] | RmqUrl[];
                                                                                                                                                                                                              queue?: string;
                                                                                                                                                                                                              prefetchCount?: number;
                                                                                                                                                                                                              isGlobalPrefetchCount?: boolean;
                                                                                                                                                                                                              queueOptions?: any;
                                                                                                                                                                                                              socketOptions?: any;
                                                                                                                                                                                                              noAck?: boolean;
                                                                                                                                                                                                              serializer?: Serializer<any, any>;
                                                                                                                                                                                                              deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                              replyQueue?: string;
                                                                                                                                                                                                              persistent?: boolean;
                                                                                                                                                                                                              },
                                                                                                                                                                                                              K extends keyof T
                                                                                                                                                                                                              >(
                                                                                                                                                                                                              obj: T,
                                                                                                                                                                                                              prop: K,
                                                                                                                                                                                                              defaultValue?: T[K]
                                                                                                                                                                                                              ) => T[K];

                                                                                                                                                                                                                method initializeDeserializer

                                                                                                                                                                                                                protected initializeDeserializer: (options: ClientOptions['options']) => void;

                                                                                                                                                                                                                  method initializeSerializer

                                                                                                                                                                                                                  protected initializeSerializer: (options: ClientOptions['options']) => void;

                                                                                                                                                                                                                    method normalizePattern

                                                                                                                                                                                                                    protected normalizePattern: (pattern: MsPattern) => string;

                                                                                                                                                                                                                      method publish

                                                                                                                                                                                                                      protected abstract publish: (
                                                                                                                                                                                                                      packet: ReadPacket,
                                                                                                                                                                                                                      callback: (packet: WritePacket) => void
                                                                                                                                                                                                                      ) => Function;

                                                                                                                                                                                                                        method send

                                                                                                                                                                                                                        send: <TResult = any, TInput = any>(pattern: any, data: TInput) => any;

                                                                                                                                                                                                                          method serializeError

                                                                                                                                                                                                                          protected serializeError: (err: any) => any;

                                                                                                                                                                                                                            method serializeResponse

                                                                                                                                                                                                                            protected serializeResponse: (response: any) => any;

                                                                                                                                                                                                                              class ClientProxyFactory

                                                                                                                                                                                                                              class ClientProxyFactory {}

                                                                                                                                                                                                                                method create

                                                                                                                                                                                                                                static create: {
                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                clientOptions: { transport: Transport.GRPC } & ClientOptions
                                                                                                                                                                                                                                ): ClientGrpcProxy;
                                                                                                                                                                                                                                (clientOptions: ClientOptions): ClientProxy & Closeable;
                                                                                                                                                                                                                                (clientOptions: CustomClientOptions): ClientProxy & Closeable;
                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                  class ClientRedis

                                                                                                                                                                                                                                  class ClientRedis extends ClientProxy {}

                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                    options: {
                                                                                                                                                                                                                                    url?: string;
                                                                                                                                                                                                                                    retryAttempts?: number;
                                                                                                                                                                                                                                    retryDelay?: number;
                                                                                                                                                                                                                                    serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                    deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                    } & ClientOpts
                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                      property connection

                                                                                                                                                                                                                                      protected connection: Promise<any>;

                                                                                                                                                                                                                                        property isExplicitlyTerminated

                                                                                                                                                                                                                                        protected isExplicitlyTerminated: boolean;

                                                                                                                                                                                                                                          property logger

                                                                                                                                                                                                                                          protected readonly logger: any;

                                                                                                                                                                                                                                            property options

                                                                                                                                                                                                                                            protected readonly options: {
                                                                                                                                                                                                                                            url?: string;
                                                                                                                                                                                                                                            retryAttempts?: number;
                                                                                                                                                                                                                                            retryDelay?: number;
                                                                                                                                                                                                                                            serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                            deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                            } & ClientOpts;

                                                                                                                                                                                                                                              property pubClient

                                                                                                                                                                                                                                              protected pubClient: RedisClient;

                                                                                                                                                                                                                                                property subClient

                                                                                                                                                                                                                                                protected subClient: RedisClient;

                                                                                                                                                                                                                                                  property subscriptionsCount

                                                                                                                                                                                                                                                  protected readonly subscriptionsCount: Map<string, number>;

                                                                                                                                                                                                                                                    property url

                                                                                                                                                                                                                                                    protected readonly url: string;

                                                                                                                                                                                                                                                      method close

                                                                                                                                                                                                                                                      close: () => void;

                                                                                                                                                                                                                                                        method connect

                                                                                                                                                                                                                                                        connect: () => Promise<any>;

                                                                                                                                                                                                                                                          method createClient

                                                                                                                                                                                                                                                          createClient: (error$: any) => RedisClient;

                                                                                                                                                                                                                                                            method createResponseCallback

                                                                                                                                                                                                                                                            createResponseCallback: () => (channel: string, buffer: string) => void;

                                                                                                                                                                                                                                                              method createRetryStrategy

                                                                                                                                                                                                                                                              createRetryStrategy: (
                                                                                                                                                                                                                                                              options: RetryStrategyOptions,
                                                                                                                                                                                                                                                              error$: any
                                                                                                                                                                                                                                                              ) => undefined | number | Error;

                                                                                                                                                                                                                                                                method dispatchEvent

                                                                                                                                                                                                                                                                protected dispatchEvent: (packet: ReadPacket) => Promise<any>;

                                                                                                                                                                                                                                                                  method getClientOptions

                                                                                                                                                                                                                                                                  getClientOptions: (error$: any) => Partial<ClientOpts>;

                                                                                                                                                                                                                                                                    method getReplyPattern

                                                                                                                                                                                                                                                                    getReplyPattern: (pattern: string) => string;

                                                                                                                                                                                                                                                                      method getRequestPattern

                                                                                                                                                                                                                                                                      getRequestPattern: (pattern: string) => string;

                                                                                                                                                                                                                                                                        method handleError

                                                                                                                                                                                                                                                                        handleError: (client: RedisClient) => void;

                                                                                                                                                                                                                                                                          method publish

                                                                                                                                                                                                                                                                          protected publish: (
                                                                                                                                                                                                                                                                          partialPacket: ReadPacket,
                                                                                                                                                                                                                                                                          callback: (packet: WritePacket) => any
                                                                                                                                                                                                                                                                          ) => Function;

                                                                                                                                                                                                                                                                            method unsubscribeFromChannel

                                                                                                                                                                                                                                                                            protected unsubscribeFromChannel: (channel: string) => void;

                                                                                                                                                                                                                                                                              class ClientRMQ

                                                                                                                                                                                                                                                                              class ClientRMQ extends ClientProxy {}

                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                constructor(options: {
                                                                                                                                                                                                                                                                                urls?: string[] | RmqUrl[];
                                                                                                                                                                                                                                                                                queue?: string;
                                                                                                                                                                                                                                                                                prefetchCount?: number;
                                                                                                                                                                                                                                                                                isGlobalPrefetchCount?: boolean;
                                                                                                                                                                                                                                                                                queueOptions?: any;
                                                                                                                                                                                                                                                                                socketOptions?: any;
                                                                                                                                                                                                                                                                                noAck?: boolean;
                                                                                                                                                                                                                                                                                serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                replyQueue?: string;
                                                                                                                                                                                                                                                                                persistent?: boolean;
                                                                                                                                                                                                                                                                                });

                                                                                                                                                                                                                                                                                  property channel

                                                                                                                                                                                                                                                                                  protected channel: any;

                                                                                                                                                                                                                                                                                    property client

                                                                                                                                                                                                                                                                                    protected client: any;

                                                                                                                                                                                                                                                                                      property connection

                                                                                                                                                                                                                                                                                      protected connection: Promise<any>;

                                                                                                                                                                                                                                                                                        property logger

                                                                                                                                                                                                                                                                                        protected readonly logger: any;

                                                                                                                                                                                                                                                                                          property options

                                                                                                                                                                                                                                                                                          protected readonly options: {
                                                                                                                                                                                                                                                                                          urls?: string[] | RmqUrl[];
                                                                                                                                                                                                                                                                                          queue?: string;
                                                                                                                                                                                                                                                                                          prefetchCount?: number;
                                                                                                                                                                                                                                                                                          isGlobalPrefetchCount?: boolean;
                                                                                                                                                                                                                                                                                          queueOptions?: any;
                                                                                                                                                                                                                                                                                          socketOptions?: any;
                                                                                                                                                                                                                                                                                          noAck?: boolean;
                                                                                                                                                                                                                                                                                          serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                          deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                          replyQueue?: string;
                                                                                                                                                                                                                                                                                          persistent?: boolean;
                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                            property persistent

                                                                                                                                                                                                                                                                                            protected persistent: boolean;

                                                                                                                                                                                                                                                                                              property queue

                                                                                                                                                                                                                                                                                              protected queue: string;

                                                                                                                                                                                                                                                                                                property queueOptions

                                                                                                                                                                                                                                                                                                protected queueOptions: any;

                                                                                                                                                                                                                                                                                                  property replyQueue

                                                                                                                                                                                                                                                                                                  protected replyQueue: string;

                                                                                                                                                                                                                                                                                                    property responseEmitter

                                                                                                                                                                                                                                                                                                    protected responseEmitter: any;

                                                                                                                                                                                                                                                                                                      property urls

                                                                                                                                                                                                                                                                                                      protected urls: string[] | RmqUrl[];

                                                                                                                                                                                                                                                                                                        method close

                                                                                                                                                                                                                                                                                                        close: () => void;

                                                                                                                                                                                                                                                                                                          method connect

                                                                                                                                                                                                                                                                                                          connect: () => Promise<any>;

                                                                                                                                                                                                                                                                                                            method consumeChannel

                                                                                                                                                                                                                                                                                                            consumeChannel: () => void;

                                                                                                                                                                                                                                                                                                              method createChannel

                                                                                                                                                                                                                                                                                                              createChannel: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                method createClient

                                                                                                                                                                                                                                                                                                                createClient: <T = any>() => T;

                                                                                                                                                                                                                                                                                                                  method dispatchEvent

                                                                                                                                                                                                                                                                                                                  protected dispatchEvent: (packet: ReadPacket) => Promise<any>;

                                                                                                                                                                                                                                                                                                                    method handleDisconnectError

                                                                                                                                                                                                                                                                                                                    handleDisconnectError: (client: any) => void;

                                                                                                                                                                                                                                                                                                                      method handleError

                                                                                                                                                                                                                                                                                                                      handleError: (client: any) => void;

                                                                                                                                                                                                                                                                                                                        method handleMessage

                                                                                                                                                                                                                                                                                                                        handleMessage: (packet: unknown, callback: (packet: WritePacket) => any) => void;

                                                                                                                                                                                                                                                                                                                          method mergeDisconnectEvent

                                                                                                                                                                                                                                                                                                                          mergeDisconnectEvent: <T = any>(instance: any, source$: any) => any;

                                                                                                                                                                                                                                                                                                                            method publish

                                                                                                                                                                                                                                                                                                                            protected publish: (
                                                                                                                                                                                                                                                                                                                            message: ReadPacket,
                                                                                                                                                                                                                                                                                                                            callback: (packet: WritePacket) => any
                                                                                                                                                                                                                                                                                                                            ) => Function;

                                                                                                                                                                                                                                                                                                                              method setupChannel

                                                                                                                                                                                                                                                                                                                              setupChannel: (channel: any, resolve: Function) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                class ClientsModule

                                                                                                                                                                                                                                                                                                                                class ClientsModule {}

                                                                                                                                                                                                                                                                                                                                  method register

                                                                                                                                                                                                                                                                                                                                  static register: (options: ClientsModuleOptions) => any;

                                                                                                                                                                                                                                                                                                                                    method registerAsync

                                                                                                                                                                                                                                                                                                                                    static registerAsync: (options: ClientsModuleAsyncOptions) => any;

                                                                                                                                                                                                                                                                                                                                      class ClientTCP

                                                                                                                                                                                                                                                                                                                                      class ClientTCP extends ClientProxy {}

                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                        constructor(options: {
                                                                                                                                                                                                                                                                                                                                        host?: string;
                                                                                                                                                                                                                                                                                                                                        port?: number;
                                                                                                                                                                                                                                                                                                                                        serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                        deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                                          property connection

                                                                                                                                                                                                                                                                                                                                          protected connection: Promise<any>;

                                                                                                                                                                                                                                                                                                                                            method bindEvents

                                                                                                                                                                                                                                                                                                                                            bindEvents: (socket: JsonSocket) => void;

                                                                                                                                                                                                                                                                                                                                              method close

                                                                                                                                                                                                                                                                                                                                              close: () => void;

                                                                                                                                                                                                                                                                                                                                                method connect

                                                                                                                                                                                                                                                                                                                                                connect: () => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                  method createSocket

                                                                                                                                                                                                                                                                                                                                                  createSocket: () => JsonSocket;

                                                                                                                                                                                                                                                                                                                                                    method dispatchEvent

                                                                                                                                                                                                                                                                                                                                                    protected dispatchEvent: (packet: ReadPacket) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                      method handleClose

                                                                                                                                                                                                                                                                                                                                                      handleClose: () => void;

                                                                                                                                                                                                                                                                                                                                                        method handleError

                                                                                                                                                                                                                                                                                                                                                        handleError: (err: any) => void;

                                                                                                                                                                                                                                                                                                                                                          method handleResponse

                                                                                                                                                                                                                                                                                                                                                          handleResponse: (buffer: unknown) => void;

                                                                                                                                                                                                                                                                                                                                                            method publish

                                                                                                                                                                                                                                                                                                                                                            protected publish: (
                                                                                                                                                                                                                                                                                                                                                            partialPacket: ReadPacket,
                                                                                                                                                                                                                                                                                                                                                            callback: (packet: WritePacket) => any
                                                                                                                                                                                                                                                                                                                                                            ) => Function;

                                                                                                                                                                                                                                                                                                                                                              class JsonSocket

                                                                                                                                                                                                                                                                                                                                                              class JsonSocket {}

                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                constructor(socket: any);

                                                                                                                                                                                                                                                                                                                                                                  property netSocket

                                                                                                                                                                                                                                                                                                                                                                  readonly netSocket: any;

                                                                                                                                                                                                                                                                                                                                                                    property socket

                                                                                                                                                                                                                                                                                                                                                                    readonly socket: any;

                                                                                                                                                                                                                                                                                                                                                                      method connect

                                                                                                                                                                                                                                                                                                                                                                      connect: (port: number, host: string) => this;

                                                                                                                                                                                                                                                                                                                                                                        method end

                                                                                                                                                                                                                                                                                                                                                                        end: () => this;

                                                                                                                                                                                                                                                                                                                                                                          method on

                                                                                                                                                                                                                                                                                                                                                                          on: (event: string, callback: (err?: any) => void) => this;

                                                                                                                                                                                                                                                                                                                                                                            method once

                                                                                                                                                                                                                                                                                                                                                                            once: (event: string, callback: (err?: any) => void) => this;

                                                                                                                                                                                                                                                                                                                                                                              method sendMessage

                                                                                                                                                                                                                                                                                                                                                                              sendMessage: (message: any, callback?: (err?: any) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                class KafkaContext

                                                                                                                                                                                                                                                                                                                                                                                class KafkaContext extends BaseRpcContext<KafkaContextArgs> {}

                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                  constructor(args: KafkaContextArgs);

                                                                                                                                                                                                                                                                                                                                                                                    method getMessage

                                                                                                                                                                                                                                                                                                                                                                                    getMessage: () => KafkaMessage;
                                                                                                                                                                                                                                                                                                                                                                                    • Returns the reference to the original message.

                                                                                                                                                                                                                                                                                                                                                                                    method getPartition

                                                                                                                                                                                                                                                                                                                                                                                    getPartition: () => number;
                                                                                                                                                                                                                                                                                                                                                                                    • Returns the partition.

                                                                                                                                                                                                                                                                                                                                                                                    method getTopic

                                                                                                                                                                                                                                                                                                                                                                                    getTopic: () => string;
                                                                                                                                                                                                                                                                                                                                                                                    • Returns the name of the topic.

                                                                                                                                                                                                                                                                                                                                                                                    class KafkaParser

                                                                                                                                                                                                                                                                                                                                                                                    class KafkaParser {}

                                                                                                                                                                                                                                                                                                                                                                                      method decode

                                                                                                                                                                                                                                                                                                                                                                                      static decode: (value: any) => object | string | null;

                                                                                                                                                                                                                                                                                                                                                                                        method parse

                                                                                                                                                                                                                                                                                                                                                                                        static parse: <T = any>(data: any) => T;

                                                                                                                                                                                                                                                                                                                                                                                          class KafkaReplyPartitionAssigner

                                                                                                                                                                                                                                                                                                                                                                                          class KafkaReplyPartitionAssigner {}

                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                            constructor(clientKafka: ClientKafka, config: { cluster: Cluster });

                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                              readonly name: string;

                                                                                                                                                                                                                                                                                                                                                                                                property version

                                                                                                                                                                                                                                                                                                                                                                                                readonly version: number;

                                                                                                                                                                                                                                                                                                                                                                                                  method assign

                                                                                                                                                                                                                                                                                                                                                                                                  assign: (group: {
                                                                                                                                                                                                                                                                                                                                                                                                  members: GroupMember[];
                                                                                                                                                                                                                                                                                                                                                                                                  topics: string[];
                                                                                                                                                                                                                                                                                                                                                                                                  }) => Promise<GroupMemberAssignment[]>;
                                                                                                                                                                                                                                                                                                                                                                                                  • This process can result in imbalanced assignments

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter members

                                                                                                                                                                                                                                                                                                                                                                                                    array of members, e.g: [{ memberId: 'test-5f93f5a3' }]

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter topics

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter userData

                                                                                                                                                                                                                                                                                                                                                                                                    Returns

                                                                                                                                                                                                                                                                                                                                                                                                    {array} object partitions per topic per member

                                                                                                                                                                                                                                                                                                                                                                                                  method decodeMember

                                                                                                                                                                                                                                                                                                                                                                                                  decodeMember: (
                                                                                                                                                                                                                                                                                                                                                                                                  member: GroupMember
                                                                                                                                                                                                                                                                                                                                                                                                  ) => { memberId: string; previousAssignment: any };

                                                                                                                                                                                                                                                                                                                                                                                                    method getPreviousAssignment

                                                                                                                                                                                                                                                                                                                                                                                                    getPreviousAssignment: () => { [key: string]: number };

                                                                                                                                                                                                                                                                                                                                                                                                      method protocol

                                                                                                                                                                                                                                                                                                                                                                                                      protocol: (subscription: { topics: string[]; userData: Buffer }) => GroupState;

                                                                                                                                                                                                                                                                                                                                                                                                        class MqttContext

                                                                                                                                                                                                                                                                                                                                                                                                        class MqttContext extends BaseRpcContext<MqttContextArgs> {}

                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                          constructor(args: MqttContextArgs);

                                                                                                                                                                                                                                                                                                                                                                                                            method getPacket

                                                                                                                                                                                                                                                                                                                                                                                                            getPacket: () => Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                            • Returns the refernce to the original MQTT packet.

                                                                                                                                                                                                                                                                                                                                                                                                            method getTopic

                                                                                                                                                                                                                                                                                                                                                                                                            getTopic: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                            • Returns the name of the topic.

                                                                                                                                                                                                                                                                                                                                                                                                            class NatsContext

                                                                                                                                                                                                                                                                                                                                                                                                            class NatsContext extends BaseRpcContext<NatsContextArgs> {}

                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                              constructor(args: NatsContextArgs);

                                                                                                                                                                                                                                                                                                                                                                                                                method getSubject

                                                                                                                                                                                                                                                                                                                                                                                                                getSubject: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                                • Returns the name of the subject.

                                                                                                                                                                                                                                                                                                                                                                                                                class NestMicroservice

                                                                                                                                                                                                                                                                                                                                                                                                                class NestMicroservice extends NestApplicationContext implements INestMicroservice {}

                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(container: any, config: MicroserviceOptions, applicationConfig: any);

                                                                                                                                                                                                                                                                                                                                                                                                                    method close

                                                                                                                                                                                                                                                                                                                                                                                                                    close: () => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                      method closeApplication

                                                                                                                                                                                                                                                                                                                                                                                                                      protected closeApplication: () => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                        method createServer

                                                                                                                                                                                                                                                                                                                                                                                                                        createServer: (config: MicroserviceOptions) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                          method dispose

                                                                                                                                                                                                                                                                                                                                                                                                                          protected dispose: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                            method init

                                                                                                                                                                                                                                                                                                                                                                                                                            init: () => Promise<this>;

                                                                                                                                                                                                                                                                                                                                                                                                                              method listen

                                                                                                                                                                                                                                                                                                                                                                                                                              listen: (callback: () => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                method listenAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                listenAsync: () => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method registerListeners

                                                                                                                                                                                                                                                                                                                                                                                                                                  registerListeners: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method registerModules

                                                                                                                                                                                                                                                                                                                                                                                                                                    registerModules: () => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method setIsInitHookCalled

                                                                                                                                                                                                                                                                                                                                                                                                                                      setIsInitHookCalled: (isInitHookCalled: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method setIsInitialized

                                                                                                                                                                                                                                                                                                                                                                                                                                        setIsInitialized: (isInitialized: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method setIsTerminated

                                                                                                                                                                                                                                                                                                                                                                                                                                          setIsTerminated: (isTerminated: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method useGlobalFilters

                                                                                                                                                                                                                                                                                                                                                                                                                                            useGlobalFilters: (...filters: ExceptionFilter[]) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method useGlobalGuards

                                                                                                                                                                                                                                                                                                                                                                                                                                              useGlobalGuards: (...guards: CanActivate[]) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method useGlobalInterceptors

                                                                                                                                                                                                                                                                                                                                                                                                                                                useGlobalInterceptors: (...interceptors: NestInterceptor[]) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method useGlobalPipes

                                                                                                                                                                                                                                                                                                                                                                                                                                                  useGlobalPipes: (...pipes: PipeTransform<any>[]) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method useWebSocketAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                    useWebSocketAdapter: (adapter: any) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      class RedisContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                      class RedisContext extends BaseRpcContext<RedisContextArgs> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(args: RedisContextArgs);

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getChannel

                                                                                                                                                                                                                                                                                                                                                                                                                                                          getChannel: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Returns the name of the channel.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          class RmqContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                          class RmqContext extends BaseRpcContext<RmqContextArgs> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(args: RmqContextArgs);

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getChannelRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                              getChannelRef: () => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Returns the reference to the original RMQ channel.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                              getMessage: () => Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Returns the original message (with properties, fields, and content).

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                              getPattern: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Returns the name of the pattern.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              class RpcException

                                                                                                                                                                                                                                                                                                                                                                                                                                                              class RpcException extends Error {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(error: string | object);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getError: () => string | object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method initMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    initMessage: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Server

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      abstract class Server {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property deserializer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected deserializer: ConsumerDeserializer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property logger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected readonly logger: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property messageHandlers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected readonly messageHandlers: Map<string, MessageHandler<any, any, any>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property serializer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected serializer: ConsumerSerializer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method addHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                addHandler: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                pattern: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: MessageHandler,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isEventHandler?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getHandlerByPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getHandlerByPattern: (pattern: string) => MessageHandler | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getHandlers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getHandlers: () => Map<string, MessageHandler>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getOptionsProp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getOptionsProp: <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T extends
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      url?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      maxSendMessageLength?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      maxReceiveMessageLength?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      maxMetadataSize?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      keepalive?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      keepaliveTimeMs?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      keepaliveTimeoutMs?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      keepalivePermitWithoutCalls?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      http2MaxPingsWithoutData?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      http2MinTimeBetweenPingsMs?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      http2MinPingIntervalWithoutDataMs?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      http2MaxPingStrikes?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      channelOptions?: ChannelOptions;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      credentials?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protoPath: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      package: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protoLoader?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      loader?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      keepCase?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      alternateCommentMode?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      longs?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enums?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bytes?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      defaults?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      arrays?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      objects?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      oneofs?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      json?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      includeDirs?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      postfixId?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      client?: KafkaConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      consumer?: ConsumerConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      run?: Omit<ConsumerRunConfig, 'eachBatch' | 'eachMessage'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      subscribe?: Omit<ConsumerSubscribeTopic, 'topic'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      producer?: ProducerConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      send?: Omit<ProducerRecord, 'topic' | 'messages'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | (MqttClientOptions & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      url?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      encoding?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      url?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      user?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pass?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      maxPingOut?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      maxReconnectAttempts?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      reconnectTimeWait?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      reconnectJitter?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      reconnectJitterTLS?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      reconnectDelayHandler?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      servers?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      nkey?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      reconnect?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pedantic?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tls?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      queue?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      userJWT?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      nonceSigner?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      userCreds?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      useOldRequestStyle?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pingInterval?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      preserveBuffers?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      waitOnFirstConnect?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      verbose?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      noEcho?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      noRandomize?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      token?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      yieldTime?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tokenHandler?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      url?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      retryAttempts?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      retryDelay?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      } & ClientOpts)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      urls?: string[] | RmqUrl[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      queue?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      prefetchCount?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isGlobalPrefetchCount?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      queueOptions?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      socketOptions?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      noAck?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      replyQueue?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      persistent?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      host?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      port?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      retryAttempts?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      retryDelay?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      K extends keyof T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      obj: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      prop: K,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      defaultValue?: T[K]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => T[K];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getRouteFromPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected getRouteFromPattern: (pattern: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Transforms the server Pattern to valid type and returns a route for him.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter pattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          server pattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method handleError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected handleError: (error: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method handleEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          handleEvent: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pattern: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          packet: ReadPacket,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          context: BaseRpcContext
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method initializeDeserializer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected initializeDeserializer: (options: ClientOptions['options']) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method initializeSerializer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected initializeSerializer: (options: ClientOptions['options']) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method loadPackage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected loadPackage: <T = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ctx: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                loader?: Function
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method normalizePattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected normalizePattern: (pattern: MsPattern) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method send

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    send: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stream$: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    respond: (data: WritePacket) => unknown | Promise<unknown>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method transformToObservable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      transformToObservable: <T = any>(resultOrDeferred: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ServerGrpc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ServerGrpc extends Server implements CustomTransportStrategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          url?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          maxSendMessageLength?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          maxReceiveMessageLength?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          maxMetadataSize?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          keepalive?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          keepaliveTimeMs?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          keepaliveTimeoutMs?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          keepalivePermitWithoutCalls?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          http2MaxPingsWithoutData?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          http2MinTimeBetweenPingsMs?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          http2MinPingIntervalWithoutDataMs?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          http2MaxPingStrikes?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          channelOptions?: ChannelOptions;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          credentials?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protoPath: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          package: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protoLoader?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          loader?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          keepCase?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          alternateCommentMode?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          longs?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          enums?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bytes?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          defaults?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arrays?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          objects?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          oneofs?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          json?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          includeDirs?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property transportId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly transportId: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method addHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              addHandler: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pattern: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callback: MessageHandler,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isEventHandler?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method bindEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bindEvents: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  close: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method createClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    createClient: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method createPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createPattern: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      service: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      methodName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      streaming: GrpcMethodStreamingType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Will create a string of a JSON serialized format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter service

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name of the service which should be a match to gRPC service definition name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter methodName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name of the method which is coming after rpc keyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter streaming

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GrpcMethodStreamingType parameter which should correspond to stream keyword in gRPC service request part

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method createRequestStreamMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createRequestStreamMethod: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      methodHandler: Function,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isResponseStream: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call: GrpcCall,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      callback: (err: unknown, value: unknown) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method createService

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        createService: (grpcService: any, name: string) => Promise<{}>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Will create service mapping from gRPC generated Object to handlers defined with or annotations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter grpcService

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method createServiceMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        createServiceMethod: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        methodHandler: Function,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protoNativeHandler: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        streamType: GrpcMethodStreamingType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Will return async function which will handle gRPC call with Rx streams or as a direct call passthrough

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter methodHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter protoNativeHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method createStreamCallMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        createStreamCallMethod: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        methodHandler: Function,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isResponseStream: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call: GrpcCall,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        callback: (err: unknown, value: unknown) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method createStreamServiceMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createStreamServiceMethod: (methodHandler: Function) => Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method createUnaryServiceMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            createUnaryServiceMethod: (methodHandler: Function) => Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method deserialize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              deserialize: (obj: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getServiceNames

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getServiceNames: (grpcPkg: any) => { name: string; service: any }[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Will return all of the services along with their fully namespaced names as an array of objects. This method initiates recursive scan of grpcPkg object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method listen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                listen: (callback: () => void) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method loadProto

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  loadProto: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method lookupPackage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    lookupPackage: (root: any, packageName: string) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      start: (callback?: () => void) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ServerKafka

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ServerKafka extends Server implements CustomTransportStrategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          postfixId?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          client?: KafkaConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          consumer?: ConsumerConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          run?: Omit<ConsumerRunConfig, 'eachBatch' | 'eachMessage'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          subscribe?: Omit<ConsumerSubscribeTopic, 'topic'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          producer?: ProducerConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          send?: Omit<ProducerRecord, 'topic' | 'messages'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property brokers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected brokers: string[] | BrokersFunction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property client

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected client: Kafka;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property clientId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected clientId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property consumer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected consumer: Consumer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property groupId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected groupId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property logger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected logger: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected readonly options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        postfixId?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        client?: KafkaConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        consumer?: ConsumerConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        run?: Omit<ConsumerRunConfig, 'eachBatch' | 'eachMessage'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        subscribe?: Omit<ConsumerSubscribeTopic, 'topic'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        producer?: ProducerConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        send?: Omit<ProducerRecord, 'topic' | 'messages'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property producer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected producer: Producer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property transportId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly transportId: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method assignCorrelationIdHeader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assignCorrelationIdHeader: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              correlationId: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              outgoingMessage: Message
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method assignErrorHeader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assignErrorHeader: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                outgoingResponse: OutgoingResponse,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                outgoingMessage: Message
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method assignIsDisposedHeader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assignIsDisposedHeader: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  outgoingResponse: OutgoingResponse,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  outgoingMessage: Message
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method assignReplyPartition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assignReplyPartition: (replyPartition: string, outgoingMessage: Message) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method bindEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bindEvents: (consumer: Consumer) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        close: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method createClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createClient: <T = any>() => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getMessageHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getMessageHandler: () => (payload: EachMessagePayload) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getPublisher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getPublisher: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              replyTopic: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              replyPartition: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              correlationId: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => (data: any) => Promise<RecordMetadata[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method handleMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                handleMessage: (payload: EachMessagePayload) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method initializeSerializer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected initializeSerializer: (options: KafkaOptions['options']) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method listen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    listen: (callback: () => void) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method sendMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sendMessage: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      message: OutgoingResponse,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      replyTopic: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      replyPartition: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      correlationId: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<RecordMetadata[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        start: (callback: () => void) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class ServerMqtt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class ServerMqtt extends Server implements CustomTransportStrategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options: MqttClientOptions & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            url?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property transportId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly transportId: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method bindEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bindEvents: (mqttClient: MqttClient) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  close: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method createMqttClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    createMqttClient: () => MqttClient;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getHandlerByPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getHandlerByPattern: (pattern: string) => MessageHandler | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getMessageHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getMessageHandler: (pub: MqttClient) => Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getPublisher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getPublisher: (client: MqttClient, pattern: any, id: string) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getReplyPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getReplyPattern: (pattern: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getRequestPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getRequestPattern: (pattern: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method handleError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                handleError: (stream: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method handleMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  handleMessage: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  channel: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  buffer: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  pub: MqttClient,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  originalPacket?: Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method listen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    listen: (callback: () => void) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method matchMqttPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      matchMqttPattern: (pattern: string, topic: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method parseMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        parseMessage: (content: any) => ReadPacket & PacketId;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          start: (callback?: () => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ServerNats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ServerNats extends Server implements CustomTransportStrategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              encoding?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              url?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              user?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pass?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              maxPingOut?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              maxReconnectAttempts?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reconnectTimeWait?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reconnectJitter?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reconnectJitterTLS?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reconnectDelayHandler?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              servers?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nkey?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reconnect?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pedantic?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tls?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              queue?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              userJWT?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nonceSigner?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              userCreds?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              useOldRequestStyle?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pingInterval?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              preserveBuffers?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              waitOnFirstConnect?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              verbose?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              noEcho?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              noRandomize?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              token?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              yieldTime?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tokenHandler?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property transportId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly transportId: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method bindEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bindEvents: (client: Client) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    close: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method createNatsClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createNatsClient: () => Client;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getMessageHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getMessageHandler: (channel: string, client: Client) => Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getPublisher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getPublisher: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          publisher: Client,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          replyTo: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          id: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => (response: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method handleError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            handleError: (stream: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method handleMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              handleMessage: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              channel: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              rawMessage: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              client: Client,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              replyTo: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callerSubject: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method listen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                listen: (callback: () => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  start: (callback?: () => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ServerRedis

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ServerRedis extends Server implements CustomTransportStrategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      url?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      retryAttempts?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      retryDelay?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      } & ClientOpts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property transportId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly transportId: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method bindEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bindEvents: (subClient: RedisClient, pubClient: RedisClient) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            close: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method createRedisClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              createRedisClient: () => RedisClient;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method createRetryStrategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                createRetryStrategy: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options: RetryStrategyOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => undefined | number | void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getClientOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getClientOptions: () => Partial<ClientOpts>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getMessageHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getMessageHandler: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pub: RedisClient
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => (channel: string, buffer: string | any) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getPublisher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getPublisher: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pub: RedisClient,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pattern: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      id: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => (response: any) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getReplyPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getReplyPattern: (pattern: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getRequestPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getRequestPattern: (pattern: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method handleError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            handleError: (stream: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method handleMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              handleMessage: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              channel: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              buffer: string | any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pub: RedisClient
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method listen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                listen: (callback: () => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method parseMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  parseMessage: (content: any) => Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    start: (callback?: () => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class ServerRMQ

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class ServerRMQ extends Server implements CustomTransportStrategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        urls?: string[] | RmqUrl[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        queue?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        prefetchCount?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isGlobalPrefetchCount?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        queueOptions?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        socketOptions?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        noAck?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        replyQueue?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        persistent?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property channel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected channel: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isGlobalPrefetchCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected readonly isGlobalPrefetchCount: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected readonly options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              urls?: string[] | RmqUrl[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              queue?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              prefetchCount?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isGlobalPrefetchCount?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              queueOptions?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              socketOptions?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              noAck?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              replyQueue?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              persistent?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property prefetchCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected readonly prefetchCount: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property queue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected readonly queue: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property queueOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected readonly queueOptions: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property server

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected server: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property transportId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly transportId: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property urls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected readonly urls: string[] | RmqUrl[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            close: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method createClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              createClient: <T = any>() => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method handleMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                handleMessage: (message: Record<string, any>, channel: any) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method listen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  listen: (callback: () => void) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method sendMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sendMessage: <T = any>(message: T, replyTo: any, correlationId: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method setupChannel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setupChannel: (channel: any, callback: Function) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        start: (callback?: () => void) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class ServerTCP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class ServerTCP extends Server implements CustomTransportStrategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            host?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            port?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            retryAttempts?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            retryDelay?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property transportId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly transportId: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method bindHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bindHandler: (socket: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  close: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method handleClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    handleClose: () => undefined | number | NodeJS.Timer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method handleMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      handleMessage: (socket: JsonSocket, rawMessage: unknown) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method listen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        listen: (callback: () => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class TcpContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class TcpContext extends BaseRpcContext<TcpContextArgs> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(args: TcpContextArgs);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getPattern: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Returns the name of the pattern.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getSocketRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getSocketRef: () => JsonSocket;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Returns the underlying JSON socket.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ClientGrpc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ClientGrpc {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getClientByServiceName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getClientByServiceName: <T = any>(name: string) => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getService

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getService: <T extends {}>(name: string) => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ClientsModuleOptionsFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ClientsModuleOptionsFactory {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method createClientOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createClientOptions: () => Promise<ClientProvider> | ClientProvider;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ClientsProviderAsyncOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ClientsProviderAsyncOptions extends Pick<ModuleMetadata, 'imports'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property extraProviders

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          extraProviders?: Provider[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property inject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            inject?: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string | symbol;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property useClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                useClass?: Type<ClientsModuleOptionsFactory>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property useExisting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  useExisting?: Type<ClientsModuleOptionsFactory>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property useFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    useFactory?: (...args: any[]) => Promise<ClientProvider> | ClientProvider;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Closeable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Closeable {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        close: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CustomClientOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CustomClientOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property customClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            customClass: Type<ClientProxy>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CustomStrategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CustomStrategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: {};

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    strategy: CustomTransportStrategy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CustomTransportStrategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CustomTransportStrategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property transportId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly transportId?: Transport;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          close: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method listen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            listen: (callback: () => void) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Deserializer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Deserializer<TInput = any, TOutput = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method deserialize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                deserialize: (value: TInput, options?: Record<string, any>) => TOutput;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GrpcOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface GrpcOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    url?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    maxSendMessageLength?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    maxReceiveMessageLength?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    maxMetadataSize?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    keepalive?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    keepaliveTimeMs?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    keepaliveTimeoutMs?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    keepalivePermitWithoutCalls?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    http2MaxPingsWithoutData?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    http2MinTimeBetweenPingsMs?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    http2MinPingIntervalWithoutDataMs?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    http2MaxPingStrikes?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    channelOptions?: ChannelOptions;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    credentials?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protoPath: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    package: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protoLoader?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    loader?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    keepCase?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    alternateCommentMode?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    longs?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enums?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bytes?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    defaults?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    arrays?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    objects?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    oneofs?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    json?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    includeDirs?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property transport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      transport?: Transport.GRPC;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface KafkaOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface KafkaOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          postfixId?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          client?: KafkaConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          consumer?: ConsumerConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          run?: Omit<ConsumerRunConfig, 'eachBatch' | 'eachMessage'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          subscribe?: Omit<ConsumerSubscribeTopic, 'topic'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          producer?: ProducerConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          send?: Omit<ProducerRecord, 'topic' | 'messages'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          serializer?: Serializer;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          deserializer?: Deserializer;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property transport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            transport?: Transport.KAFKA;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MessageHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MessageHandler<TInput = any, TContext = any, TResult = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property isEventHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isEventHandler?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (data: TInput, ctx?: TContext): Promise<Observable<TResult>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface MqttOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface MqttOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: MqttClientOptions & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      url?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      serializer?: Serializer;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      deserializer?: Deserializer;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property transport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        transport?: Transport.MQTT;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MsObjectPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MsObjectPattern {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [key: string]: MsFundamentalPattern | MsObjectPattern;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface NatsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface NatsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                encoding?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                url?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                user?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                pass?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                maxPingOut?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                maxReconnectAttempts?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                reconnectTimeWait?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                reconnectJitter?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                reconnectJitterTLS?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                reconnectDelayHandler?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                servers?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                nkey?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                reconnect?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                pedantic?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tls?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                queue?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                serializer?: Serializer;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                deserializer?: Deserializer;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                userJWT?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                nonceSigner?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                userCreds?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                useOldRequestStyle?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                pingInterval?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                preserveBuffers?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                waitOnFirstConnect?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                verbose?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                noEcho?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                noRandomize?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                token?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                yieldTime?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tokenHandler?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property transport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  transport?: Transport.NATS;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface PacketId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface PacketId {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PatternMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PatternMetadata {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [prop: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ReadPacket

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ReadPacket<T = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              data: T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property pattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                pattern: any;</