@nestjs/microservices

  • Version 10.2.10
  • Published
  • 385 kB
  • 2 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 EventPattern

    const EventPattern: {
    <T = string>(metadata?: T): MethodDecorator;
    <T = string>(metadata?: T, transport?: Transport | symbol): MethodDecorator;
    <T = string>(metadata?: T, extras?: Record<string, any>): MethodDecorator;
    <T = string>(
    metadata?: T,
    transport?: Transport | symbol,
    extras?: Record<string, any>
    ): MethodDecorator;
    };
    • Subscribes to incoming events which fulfils chosen pattern.

    variable GrpcService

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

    variable MessagePattern

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

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

          Payload: {
          (): ParameterDecorator;
          (...pipes: any[]): ParameterDecorator;
          (propertyKey?: string, ...pipes: any[]): ParameterDecorator;
          };
          • Microservice message pattern payload parameter decorator.

          • Microservice message pattern payload parameter decorator.

            Example:

            create(@Payload(new ValidationPipe()) createDto: CreateCatDto)

            Parameter pipes

            one or more pipes - either instances or classes - to apply to the bound parameter.

          • Microservice message pattern payload parameter decorator. Extracts a property from the payload object. May also apply pipes to the bound parameter.

            For example, extracting all params:

            findMany(@Payload() ids: string[])

            For example, extracting a single param:

            create(@Payload('data') createDto: { data: string })

            For example, extracting a single param with pipe:

            create(@Payload('data', new ValidationPipe()) createDto: { data: string })

            Parameter propertyKey

            name of single property to extract from the message payload

            Parameter pipes

            one or more pipes - either instances or classes - to apply to the bound parameter.

          Classes

          class BaseRpcContext

          class BaseRpcContext<T = unknown[]> {}

            constructor

            constructor(args: {});

              property args

              protected readonly args: {};

                method getArgByIndex

                getArgByIndex: (index: number) => any;
                • Returns a particular argument by index.

                  Parameter index

                  index of argument to retrieve

                method getArgs

                getArgs: () => T;
                • Returns the array of arguments being passed to the handler.

                class BaseRpcExceptionFilter

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

                method catch

                catch: (exception: T, host: ArgumentsHost) => Observable<R>;

                  method handleUnknownError

                  handleUnknownError: (exception: T, status: string) => Observable<never>;

                    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;
                      packageDefinition?: any;
                      gracefulShutdown?: boolean;
                      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: Logger;

                              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;
                              packageDefinition?: any;
                              gracefulShutdown?: boolean;
                              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[]) => Observable<unknown>;

                                            method createStreamServiceMethod

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

                                              method createUnaryServiceMethod

                                              createUnaryServiceMethod: (
                                              client: any,
                                              methodName: string
                                              ) => (...args: any[]) => Observable<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
                                                                ) => Observable<TResult>;

                                                                  class ClientKafka

                                                                  class ClientKafka extends ClientProxy {}

                                                                  constructor

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

                                                                    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 initialized

                                                                                protected initialized: Promise<void>;

                                                                                  property logger

                                                                                  protected logger: Logger;

                                                                                    property options

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

                                                                                      property parser

                                                                                      protected parser: KafkaParser;

                                                                                        property producer

                                                                                        protected producer: Producer;

                                                                                          property producerOnlyMode

                                                                                          protected producerOnlyMode: boolean;

                                                                                            property responsePatterns

                                                                                            protected responsePatterns: string[];

                                                                                              method bindTopics

                                                                                              bindTopics: () => Promise<void>;

                                                                                                method close

                                                                                                close: () => Promise<void>;

                                                                                                  method commitOffsets

                                                                                                  commitOffsets: (
                                                                                                  topicPartitions: TopicPartitionOffsetAndMetadata[]
                                                                                                  ) => 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
                                                                                                                      ) => () => void;

                                                                                                                        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>;
                                                                                                                            subscribeOptions?: {
                                                                                                                            qos: QoS;
                                                                                                                            nl?: boolean;
                                                                                                                            rap?: boolean;
                                                                                                                            rh?: number;
                                                                                                                            };
                                                                                                                            userProperties?: Record<string, string | string[]>;
                                                                                                                            }
                                                                                                                            );

                                                                                                                              property connection

                                                                                                                              protected connection: Promise<any>;

                                                                                                                                property logger

                                                                                                                                protected readonly logger: Logger;

                                                                                                                                  property mqttClient

                                                                                                                                  protected mqttClient: MqttClient;

                                                                                                                                    property options

                                                                                                                                    protected readonly options: MqttClientOptions & {
                                                                                                                                    url?: string;
                                                                                                                                    serializer?: Serializer<any, any>;
                                                                                                                                    deserializer?: Deserializer<any, any>;
                                                                                                                                    subscribeOptions?: { qos: QoS; nl?: boolean; rap?: boolean; rh?: number };
                                                                                                                                    userProperties?: Record<string, string | string[]>;
                                                                                                                                    };

                                                                                                                                      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: Buffer) => 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 initializeSerializer

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

                                                                                                                                                            method mergeCloseEvent

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

                                                                                                                                                              method mergePacketOptions

                                                                                                                                                              protected mergePacketOptions: (
                                                                                                                                                              requestOptions?: MqttRecordOptions
                                                                                                                                                              ) => MqttRecordOptions | undefined;

                                                                                                                                                                method publish

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

                                                                                                                                                                  method unsubscribeFromChannel

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

                                                                                                                                                                    class ClientNats

                                                                                                                                                                    class ClientNats extends ClientProxy {}

                                                                                                                                                                    constructor

                                                                                                                                                                    constructor(options: {
                                                                                                                                                                    [key: string]: any;
                                                                                                                                                                    headers?: Record<string, string>;
                                                                                                                                                                    authenticator?: any;
                                                                                                                                                                    debug?: boolean;
                                                                                                                                                                    ignoreClusterUpdates?: boolean;
                                                                                                                                                                    inboxPrefix?: string;
                                                                                                                                                                    encoding?: string;
                                                                                                                                                                    name?: string;
                                                                                                                                                                    user?: string;
                                                                                                                                                                    pass?: string;
                                                                                                                                                                    maxPingOut?: number;
                                                                                                                                                                    maxReconnectAttempts?: number;
                                                                                                                                                                    reconnectTimeWait?: number;
                                                                                                                                                                    reconnectJitter?: number;
                                                                                                                                                                    reconnectJitterTLS?: number;
                                                                                                                                                                    reconnectDelayHandler?: any;
                                                                                                                                                                    servers?: string | 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 logger

                                                                                                                                                                      protected readonly logger: Logger;

                                                                                                                                                                        property natsClient

                                                                                                                                                                        protected natsClient: Client;

                                                                                                                                                                          property options

                                                                                                                                                                          protected readonly options: {
                                                                                                                                                                          [key: string]: any;
                                                                                                                                                                          headers?: Record<string, string>;
                                                                                                                                                                          authenticator?: any;
                                                                                                                                                                          debug?: boolean;
                                                                                                                                                                          ignoreClusterUpdates?: boolean;
                                                                                                                                                                          inboxPrefix?: string;
                                                                                                                                                                          encoding?: string;
                                                                                                                                                                          name?: string;
                                                                                                                                                                          user?: string;
                                                                                                                                                                          pass?: string;
                                                                                                                                                                          maxPingOut?: number;
                                                                                                                                                                          maxReconnectAttempts?: number;
                                                                                                                                                                          reconnectTimeWait?: number;
                                                                                                                                                                          reconnectJitter?: number;
                                                                                                                                                                          reconnectJitterTLS?: number;
                                                                                                                                                                          reconnectDelayHandler?: any;
                                                                                                                                                                          servers?: string | 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;
                                                                                                                                                                          };

                                                                                                                                                                            method close

                                                                                                                                                                            close: () => Promise<void>;

                                                                                                                                                                              method connect

                                                                                                                                                                              connect: () => Promise<any>;

                                                                                                                                                                                method createClient

                                                                                                                                                                                createClient: () => Promise<Client>;

                                                                                                                                                                                  method createSubscriptionHandler

                                                                                                                                                                                  createSubscriptionHandler: (
                                                                                                                                                                                  packet: ReadPacket & PacketId,
                                                                                                                                                                                  callback: (packet: WritePacket) => any
                                                                                                                                                                                  ) => (error: unknown | undefined, natsMsg: NatsMsg) => Promise<any>;

                                                                                                                                                                                    method dispatchEvent

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

                                                                                                                                                                                      method handleStatusUpdates

                                                                                                                                                                                      handleStatusUpdates: (client: Client) => Promise<void>;

                                                                                                                                                                                        method initializeDeserializer

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

                                                                                                                                                                                          method initializeSerializer

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

                                                                                                                                                                                            method mergeHeaders

                                                                                                                                                                                            protected mergeHeaders: <THeaders = any>(requestHeaders?: THeaders) => any;

                                                                                                                                                                                              method publish

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

                                                                                                                                                                                                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
                                                                                                                                                                                                              ) => Observable<any>;

                                                                                                                                                                                                                method createObserver

                                                                                                                                                                                                                protected createObserver: <T>(
                                                                                                                                                                                                                observer: Observer<T>
                                                                                                                                                                                                                ) => (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
                                                                                                                                                                                                                    ) => Observable<TResult>;

                                                                                                                                                                                                                      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;
                                                                                                                                                                                                                      packageDefinition?: any;
                                                                                                                                                                                                                      gracefulShutdown?: boolean;
                                                                                                                                                                                                                      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<ConsumerSubscribeTopics, 'topics'>;
                                                                                                                                                                                                                      producer?: ProducerConfig;
                                                                                                                                                                                                                      send?: Omit<ProducerRecord, 'topic' | 'messages'>;
                                                                                                                                                                                                                      serializer?: Serializer<any, any>;
                                                                                                                                                                                                                      deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                      parser?: KafkaParserConfig;
                                                                                                                                                                                                                      producerOnlyMode?: boolean;
                                                                                                                                                                                                                      }
                                                                                                                                                                                                                      | (MqttClientOptions & {
                                                                                                                                                                                                                      url?: string;
                                                                                                                                                                                                                      serializer?: Serializer<any, any>;
                                                                                                                                                                                                                      deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                      subscribeOptions?: {
                                                                                                                                                                                                                      qos: QoS;
                                                                                                                                                                                                                      nl?: boolean;
                                                                                                                                                                                                                      rap?: boolean;
                                                                                                                                                                                                                      rh?: number;
                                                                                                                                                                                                                      };
                                                                                                                                                                                                                      userProperties?: Record<string, string | string[]>;
                                                                                                                                                                                                                      })
                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                                                                      headers?: Record<string, string>;
                                                                                                                                                                                                                      authenticator?: any;
                                                                                                                                                                                                                      debug?: boolean;
                                                                                                                                                                                                                      ignoreClusterUpdates?: boolean;
                                                                                                                                                                                                                      inboxPrefix?: string;
                                                                                                                                                                                                                      encoding?: string;
                                                                                                                                                                                                                      name?: string;
                                                                                                                                                                                                                      user?: string;
                                                                                                                                                                                                                      pass?: string;
                                                                                                                                                                                                                      maxPingOut?: number;
                                                                                                                                                                                                                      maxReconnectAttempts?: number;
                                                                                                                                                                                                                      reconnectTimeWait?: number;
                                                                                                                                                                                                                      reconnectJitter?: number;
                                                                                                                                                                                                                      reconnectJitterTLS?: number;
                                                                                                                                                                                                                      reconnectDelayHandler?: any;
                                                                                                                                                                                                                      servers?: string | 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;
                                                                                                                                                                                                                      }
                                                                                                                                                                                                                      | ({
                                                                                                                                                                                                                      host?: string;
                                                                                                                                                                                                                      port?: number;
                                                                                                                                                                                                                      retryAttempts?: number;
                                                                                                                                                                                                                      retryDelay?: number;
                                                                                                                                                                                                                      wildcards?: boolean;
                                                                                                                                                                                                                      serializer?: Serializer<any, any>;
                                                                                                                                                                                                                      deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                      } & IORedisOptions)
                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                      host?: string;
                                                                                                                                                                                                                      port?: number;
                                                                                                                                                                                                                      serializer?: Serializer<any, any>;
                                                                                                                                                                                                                      deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                      tlsOptions?: ConnectionOptions;
                                                                                                                                                                                                                      socketClass?: Type<TcpSocket>;
                                                                                                                                                                                                                      }
                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                      urls?: string[] | RmqUrl[];
                                                                                                                                                                                                                      queue?: string;
                                                                                                                                                                                                                      prefetchCount?: number;
                                                                                                                                                                                                                      isGlobalPrefetchCount?: boolean;
                                                                                                                                                                                                                      queueOptions?: any;
                                                                                                                                                                                                                      socketOptions?: any;
                                                                                                                                                                                                                      noAck?: boolean;
                                                                                                                                                                                                                      consumerTag?: string;
                                                                                                                                                                                                                      serializer?: Serializer<any, any>;
                                                                                                                                                                                                                      deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                      replyQueue?: string;
                                                                                                                                                                                                                      persistent?: boolean;
                                                                                                                                                                                                                      headers?: Record<string, string>;
                                                                                                                                                                                                                      noAssert?: boolean;
                                                                                                                                                                                                                      maxConnectionAttempts?: number;
                                                                                                                                                                                                                      },
                                                                                                                                                                                                                      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
                                                                                                                                                                                                                              ) => () => void;

                                                                                                                                                                                                                                method send

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

                                                                                                                                                                                                                                  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: {
                                                                                                                                                                                                                                        host?: string;
                                                                                                                                                                                                                                        port?: number;
                                                                                                                                                                                                                                        retryAttempts?: number;
                                                                                                                                                                                                                                        retryDelay?: number;
                                                                                                                                                                                                                                        wildcards?: boolean;
                                                                                                                                                                                                                                        serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                        deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                        } & IORedisOptions
                                                                                                                                                                                                                                        );

                                                                                                                                                                                                                                          property connection

                                                                                                                                                                                                                                          protected connection: Promise<any>;

                                                                                                                                                                                                                                            property isExplicitlyTerminated

                                                                                                                                                                                                                                            protected isExplicitlyTerminated: boolean;

                                                                                                                                                                                                                                              property logger

                                                                                                                                                                                                                                              protected readonly logger: Logger;

                                                                                                                                                                                                                                                property options

                                                                                                                                                                                                                                                protected readonly options: {
                                                                                                                                                                                                                                                host?: string;
                                                                                                                                                                                                                                                port?: number;
                                                                                                                                                                                                                                                retryAttempts?: number;
                                                                                                                                                                                                                                                retryDelay?: number;
                                                                                                                                                                                                                                                wildcards?: boolean;
                                                                                                                                                                                                                                                serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                } & IORedisOptions;

                                                                                                                                                                                                                                                  property pubClient

                                                                                                                                                                                                                                                  protected pubClient: any;

                                                                                                                                                                                                                                                    property subClient

                                                                                                                                                                                                                                                    protected subClient: any;

                                                                                                                                                                                                                                                      property subscriptionsCount

                                                                                                                                                                                                                                                      protected readonly subscriptionsCount: Map<string, number>;

                                                                                                                                                                                                                                                        method close

                                                                                                                                                                                                                                                        close: () => void;

                                                                                                                                                                                                                                                          method connect

                                                                                                                                                                                                                                                          connect: () => Promise<any>;

                                                                                                                                                                                                                                                            method createClient

                                                                                                                                                                                                                                                            createClient: () => Redis;

                                                                                                                                                                                                                                                              method createResponseCallback

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

                                                                                                                                                                                                                                                                method createRetryStrategy

                                                                                                                                                                                                                                                                createRetryStrategy: (times: number) => undefined | number;

                                                                                                                                                                                                                                                                  method dispatchEvent

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

                                                                                                                                                                                                                                                                    method getClientOptions

                                                                                                                                                                                                                                                                    getClientOptions: () => Partial<RedisOptions['options']>;

                                                                                                                                                                                                                                                                      method getReplyPattern

                                                                                                                                                                                                                                                                      getReplyPattern: (pattern: string) => string;

                                                                                                                                                                                                                                                                        method getRequestPattern

                                                                                                                                                                                                                                                                        getRequestPattern: (pattern: string) => string;

                                                                                                                                                                                                                                                                          method handleError

                                                                                                                                                                                                                                                                          handleError: (client: Redis) => void;

                                                                                                                                                                                                                                                                            method publish

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

                                                                                                                                                                                                                                                                              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;
                                                                                                                                                                                                                                                                                consumerTag?: string;
                                                                                                                                                                                                                                                                                serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                replyQueue?: string;
                                                                                                                                                                                                                                                                                persistent?: boolean;
                                                                                                                                                                                                                                                                                headers?: Record<string, string>;
                                                                                                                                                                                                                                                                                noAssert?: boolean;
                                                                                                                                                                                                                                                                                maxConnectionAttempts?: number;
                                                                                                                                                                                                                                                                                });

                                                                                                                                                                                                                                                                                  property channel

                                                                                                                                                                                                                                                                                  protected channel: any;

                                                                                                                                                                                                                                                                                    property client

                                                                                                                                                                                                                                                                                    protected client: any;

                                                                                                                                                                                                                                                                                      property connection

                                                                                                                                                                                                                                                                                      protected connection: Promise<any>;

                                                                                                                                                                                                                                                                                        property connection$

                                                                                                                                                                                                                                                                                        protected connection$: ReplaySubject<any>;

                                                                                                                                                                                                                                                                                          property logger

                                                                                                                                                                                                                                                                                          protected readonly logger: Logger;

                                                                                                                                                                                                                                                                                            property noAssert

                                                                                                                                                                                                                                                                                            protected noAssert: boolean;

                                                                                                                                                                                                                                                                                              property options

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

                                                                                                                                                                                                                                                                                                property persistent

                                                                                                                                                                                                                                                                                                protected persistent: boolean;

                                                                                                                                                                                                                                                                                                  property queue

                                                                                                                                                                                                                                                                                                  protected queue: string;

                                                                                                                                                                                                                                                                                                    property queueOptions

                                                                                                                                                                                                                                                                                                    protected queueOptions: Record<string, any>;

                                                                                                                                                                                                                                                                                                      property replyQueue

                                                                                                                                                                                                                                                                                                      protected replyQueue: string;

                                                                                                                                                                                                                                                                                                        property responseEmitter

                                                                                                                                                                                                                                                                                                        protected responseEmitter: EventEmitter;

                                                                                                                                                                                                                                                                                                          property urls

                                                                                                                                                                                                                                                                                                          protected urls: string[] | RmqUrl[];

                                                                                                                                                                                                                                                                                                            method close

                                                                                                                                                                                                                                                                                                            close: () => void;

                                                                                                                                                                                                                                                                                                              method connect

                                                                                                                                                                                                                                                                                                              connect: () => Promise<any>;

                                                                                                                                                                                                                                                                                                                method consumeChannel

                                                                                                                                                                                                                                                                                                                consumeChannel: (channel: Channel) => Promise<void>;

                                                                                                                                                                                                                                                                                                                  method convertConnectionToPromise

                                                                                                                                                                                                                                                                                                                  convertConnectionToPromise: () => Promise<any>;

                                                                                                                                                                                                                                                                                                                    method createChannel

                                                                                                                                                                                                                                                                                                                    createChannel: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                      method createClient

                                                                                                                                                                                                                                                                                                                      createClient: () => AmqpConnectionManager;

                                                                                                                                                                                                                                                                                                                        method dispatchEvent

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

                                                                                                                                                                                                                                                                                                                          method handleDisconnectError

                                                                                                                                                                                                                                                                                                                          handleDisconnectError: (client: AmqpConnectionManager) => void;

                                                                                                                                                                                                                                                                                                                            method handleError

                                                                                                                                                                                                                                                                                                                            handleError: (client: AmqpConnectionManager) => void;

                                                                                                                                                                                                                                                                                                                              method handleMessage

                                                                                                                                                                                                                                                                                                                              handleMessage: {
                                                                                                                                                                                                                                                                                                                              (packet: unknown, callback: (packet: WritePacket) => any): any;
                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                              packet: unknown,
                                                                                                                                                                                                                                                                                                                              options: Record<string, unknown>,
                                                                                                                                                                                                                                                                                                                              callback: (packet: WritePacket<any>) => any
                                                                                                                                                                                                                                                                                                                              ): any;
                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                method initializeSerializer

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

                                                                                                                                                                                                                                                                                                                                  method mergeDisconnectEvent

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

                                                                                                                                                                                                                                                                                                                                    method mergeHeaders

                                                                                                                                                                                                                                                                                                                                    protected mergeHeaders: (
                                                                                                                                                                                                                                                                                                                                    requestHeaders?: Record<string, string>
                                                                                                                                                                                                                                                                                                                                    ) => Record<string, string> | undefined;

                                                                                                                                                                                                                                                                                                                                      method parseMessageContent

                                                                                                                                                                                                                                                                                                                                      protected parseMessageContent: (content: Buffer) => any;

                                                                                                                                                                                                                                                                                                                                        method publish

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

                                                                                                                                                                                                                                                                                                                                          method setupChannel

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

                                                                                                                                                                                                                                                                                                                                            class ClientsModule

                                                                                                                                                                                                                                                                                                                                            class ClientsModule {}

                                                                                                                                                                                                                                                                                                                                              method register

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

                                                                                                                                                                                                                                                                                                                                                method registerAsync

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

                                                                                                                                                                                                                                                                                                                                                  class ClientTCP

                                                                                                                                                                                                                                                                                                                                                  class ClientTCP extends ClientProxy {}

                                                                                                                                                                                                                                                                                                                                                  constructor

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

                                                                                                                                                                                                                                                                                                                                                    property connection

                                                                                                                                                                                                                                                                                                                                                    protected connection: Promise<any>;

                                                                                                                                                                                                                                                                                                                                                      property tlsOptions

                                                                                                                                                                                                                                                                                                                                                      tlsOptions?: ConnectionOptions;

                                                                                                                                                                                                                                                                                                                                                        method bindEvents

                                                                                                                                                                                                                                                                                                                                                        bindEvents: (socket: TcpSocket) => void;

                                                                                                                                                                                                                                                                                                                                                          method close

                                                                                                                                                                                                                                                                                                                                                          close: () => void;

                                                                                                                                                                                                                                                                                                                                                            method connect

                                                                                                                                                                                                                                                                                                                                                            connect: () => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                              method createSocket

                                                                                                                                                                                                                                                                                                                                                              createSocket: () => TcpSocket;

                                                                                                                                                                                                                                                                                                                                                                method dispatchEvent

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

                                                                                                                                                                                                                                                                                                                                                                  method handleClose

                                                                                                                                                                                                                                                                                                                                                                  handleClose: () => void;

                                                                                                                                                                                                                                                                                                                                                                    method handleError

                                                                                                                                                                                                                                                                                                                                                                    handleError: (err: any) => void;

                                                                                                                                                                                                                                                                                                                                                                      method handleResponse

                                                                                                                                                                                                                                                                                                                                                                      handleResponse: (buffer: unknown) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                        method publish

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

                                                                                                                                                                                                                                                                                                                                                                          class JsonSocket

                                                                                                                                                                                                                                                                                                                                                                          class JsonSocket extends TcpSocket {}

                                                                                                                                                                                                                                                                                                                                                                            method handleData

                                                                                                                                                                                                                                                                                                                                                                            protected handleData: (dataRaw: Buffer | string) => void;

                                                                                                                                                                                                                                                                                                                                                                              method handleSend

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

                                                                                                                                                                                                                                                                                                                                                                                class KafkaContext

                                                                                                                                                                                                                                                                                                                                                                                class KafkaContext extends BaseRpcContext<KafkaContextArgs> {}

                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                  constructor(args: KafkaContextArgs);

                                                                                                                                                                                                                                                                                                                                                                                    method getConsumer

                                                                                                                                                                                                                                                                                                                                                                                    getConsumer: () => Consumer;
                                                                                                                                                                                                                                                                                                                                                                                    • Returns the Kafka consumer reference.

                                                                                                                                                                                                                                                                                                                                                                                    method getHeartbeat

                                                                                                                                                                                                                                                                                                                                                                                    getHeartbeat: () => () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                    • Returns the Kafka heartbeat callback.

                                                                                                                                                                                                                                                                                                                                                                                    method getMessage

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

                                                                                                                                                                                                                                                                                                                                                                                    method getPartition

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

                                                                                                                                                                                                                                                                                                                                                                                    method getProducer

                                                                                                                                                                                                                                                                                                                                                                                    getProducer: () => Producer;
                                                                                                                                                                                                                                                                                                                                                                                    • Returns the Kafka producer reference,

                                                                                                                                                                                                                                                                                                                                                                                    method getTopic

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

                                                                                                                                                                                                                                                                                                                                                                                    class KafkaParser

                                                                                                                                                                                                                                                                                                                                                                                    class KafkaParser {}

                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                      constructor(config?: KafkaParserConfig);

                                                                                                                                                                                                                                                                                                                                                                                        property keepBinary

                                                                                                                                                                                                                                                                                                                                                                                        protected readonly keepBinary: boolean;

                                                                                                                                                                                                                                                                                                                                                                                          method decode

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

                                                                                                                                                                                                                                                                                                                                                                                            method parse

                                                                                                                                                                                                                                                                                                                                                                                            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 KafkaRetriableException

                                                                                                                                                                                                                                                                                                                                                                                                            class KafkaRetriableException extends RpcException {}
                                                                                                                                                                                                                                                                                                                                                                                                            • Exception that instructs Kafka driver to instead of introspecting error processing flow and sending serialized error message to the consumer, force bubble it up to the "eachMessage" callback of the underlying "kafkajs" package (even if interceptors are applied, or an observable stream is returned from the message handler).

                                                                                                                                                                                                                                                                                                                                                                                                              A transient exception that if retried may succeed.

                                                                                                                                                                                                                                                                                                                                                                                                            method getError

                                                                                                                                                                                                                                                                                                                                                                                                            getError: () => string | object;

                                                                                                                                                                                                                                                                                                                                                                                                              class MqttContext

                                                                                                                                                                                                                                                                                                                                                                                                              class MqttContext extends BaseRpcContext<MqttContextArgs> {}

                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                constructor(args: MqttContextArgs);

                                                                                                                                                                                                                                                                                                                                                                                                                  method getPacket

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

                                                                                                                                                                                                                                                                                                                                                                                                                  method getTopic

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

                                                                                                                                                                                                                                                                                                                                                                                                                  class MqttRecord

                                                                                                                                                                                                                                                                                                                                                                                                                  class MqttRecord<TData = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(data: {}, options?: MqttRecordOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                      property data

                                                                                                                                                                                                                                                                                                                                                                                                                      readonly data: {};

                                                                                                                                                                                                                                                                                                                                                                                                                        property options

                                                                                                                                                                                                                                                                                                                                                                                                                        options?: MqttRecordOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                          class MqttRecordBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                          class MqttRecordBuilder<TData> {}

                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(data?: {});

                                                                                                                                                                                                                                                                                                                                                                                                                              method build

                                                                                                                                                                                                                                                                                                                                                                                                                              build: () => MqttRecord;

                                                                                                                                                                                                                                                                                                                                                                                                                                method setData

                                                                                                                                                                                                                                                                                                                                                                                                                                setData: (data: TData) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method setDup

                                                                                                                                                                                                                                                                                                                                                                                                                                  setDup: (dup: MqttRecordOptions['dup']) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method setProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                    setProperties: (properties: MqttRecordOptions['properties']) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method setQoS

                                                                                                                                                                                                                                                                                                                                                                                                                                      setQoS: (qos: MqttRecordOptions['qos']) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method setRetain

                                                                                                                                                                                                                                                                                                                                                                                                                                        setRetain: (retain: MqttRecordOptions['retain']) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                          class NatsContext

                                                                                                                                                                                                                                                                                                                                                                                                                                          class NatsContext extends BaseRpcContext<NatsContextArgs> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(args: NatsContextArgs);

                                                                                                                                                                                                                                                                                                                                                                                                                                              method getHeaders

                                                                                                                                                                                                                                                                                                                                                                                                                                              getHeaders: () => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                              • Returns message headers (if exist).

                                                                                                                                                                                                                                                                                                                                                                                                                                              method getSubject

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

                                                                                                                                                                                                                                                                                                                                                                                                                                              class NatsRecord

                                                                                                                                                                                                                                                                                                                                                                                                                                              class NatsRecord<TData = any, THeaders = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(data: {}, headers?: {});

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly data: {};

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property headers

                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly headers?: {};

                                                                                                                                                                                                                                                                                                                                                                                                                                                      class NatsRecordBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                      class NatsRecordBuilder<TData> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(data?: {});

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method build

                                                                                                                                                                                                                                                                                                                                                                                                                                                          build: () => NatsRecord;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method setData

                                                                                                                                                                                                                                                                                                                                                                                                                                                            setData: (data: TData) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method setHeaders

                                                                                                                                                                                                                                                                                                                                                                                                                                                              setHeaders: <THeaders = any>(headers: THeaders) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                class NestMicroservice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                class NestMicroservice
                                                                                                                                                                                                                                                                                                                                                                                                                                                                extends NestApplicationContext<NestMicroserviceOptions>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                implements INestMicroservice {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  container: NestContainer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  config: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  graphInspector: GraphInspector,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  applicationConfig: ApplicationConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property logger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected readonly logger: Logger;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      close: () => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method closeApplication

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method createServer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createServer: (config: NestMicroserviceOptions & MicroserviceOptions) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method dispose

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method init

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              init: () => Promise<this>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method listen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                listen: () => 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: WebSocketAdapter) => 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 RmqRecord

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class RmqRecord<TData = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(data: {}, options?: RmqRecordOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly data: {};

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: RmqRecordOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class RmqRecordBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class RmqRecordBuilder<TData> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(data?: {});

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method build

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          build: () => RmqRecord;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method setData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setData: (data: TData) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method setOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setOptions: (options: RmqRecordOptions) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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: LoggerService;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                extras?: Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => 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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      packageDefinition?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      gracefulShutdown?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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<ConsumerSubscribeTopics, 'topics'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      producer?: ProducerConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      send?: Omit<ProducerRecord, 'topic' | 'messages'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      parser?: KafkaParserConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      producerOnlyMode?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | (MqttClientOptions & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      url?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      subscribeOptions?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      qos: QoS;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      nl?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      rap?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      rh?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      userProperties?: Record<string, string | string[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      headers?: Record<string, string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      authenticator?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      debug?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreClusterUpdates?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      inboxPrefix?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      encoding?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      user?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pass?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      maxPingOut?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      maxReconnectAttempts?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      reconnectTimeWait?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      reconnectJitter?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      reconnectJitterTLS?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      reconnectDelayHandler?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      servers?: string | 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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      host?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      port?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      retryAttempts?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      retryDelay?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      wildcards?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      } & IORedisOptions)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      urls?: string[] | RmqUrl[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      queue?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      prefetchCount?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isGlobalPrefetchCount?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      queueOptions?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      socketOptions?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      noAck?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      consumerTag?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      replyQueue?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      persistent?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      headers?: Record<string, string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      noAssert?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      maxConnectionAttempts?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      host?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      port?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      retryAttempts?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      retryDelay?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tlsOptions?: ConnectionOptions;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      socketClass?: Type<TcpSocket>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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$: Observable<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    respond: (data: WritePacket) => unknown | Promise<unknown>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Subscription;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method transformToObservable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      transformToObservable: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <T>(resultOrDeferred: Observable<T> | Promise<T>): Observable<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <T>(resultOrDeferred: T): Observable<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          packageDefinition?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          gracefulShutdown?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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: unknown,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callback: MessageHandler,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isEventHandler?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method bindEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bindEvents: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  close: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method createClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    createClient: () => Promise<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: (err?: unknown, ...optionalParams: unknown[]) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method loadProto

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  loadProto: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method lookupPackage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method start

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method writeObservableToGrpc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        writeObservableToGrpc: <T>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: Observable<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call: GrpcCall<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Writes an observable to a GRPC call.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This function will ensure that backpressure is managed while writing values that come from an observable to a GRPC call.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The observable we want to write out to the GRPC call.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The GRPC call we want to write to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A promise that resolves when we're done writing to the call.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ServerKafka

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ServerKafka extends Server implements CustomTransportStrategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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: Logger;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property options

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property parser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected parser: KafkaParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 handleEvent

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method handleMessage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method initializeDeserializer

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method initializeSerializer

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method listen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          listen: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          callback: (err?: unknown, ...optionalParams: unknown[]) => 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>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  subscribeOptions?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  qos: QoS;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  nl?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  rap?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  rh?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  userProperties?: Record<string, string | string[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property mqttClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected mqttClient: MqttClient;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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: Buffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pub: MqttClient,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          originalPacket?: Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method initializeSerializer

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method listen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              listen: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callback: (err?: unknown, ...optionalParams: unknown[]) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method matchMqttPattern

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method parseMessage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method removeHandlerKeySharedPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    removeHandlerKeySharedPrefix: (handlerKey: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      start: (callback: (err?: unknown, ...optionalParams: unknown[]) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ServerNats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ServerNats extends Server implements CustomTransportStrategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers?: Record<string, string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          authenticator?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          debug?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ignoreClusterUpdates?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          inboxPrefix?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          encoding?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          user?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pass?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          maxPingOut?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          maxReconnectAttempts?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reconnectTimeWait?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reconnectJitter?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reconnectJitterTLS?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reconnectDelayHandler?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          servers?: string | 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: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method createNatsClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  createNatsClient: () => Promise<Client>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getMessageHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getMessageHandler: (channel: string) => Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getPublisher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getPublisher: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      natsMsg: NatsMsg,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      id: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => ((response: any) => boolean) | (() => void);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method handleMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        handleMessage: (channel: string, natsMsg: NatsMsg) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method handleStatusUpdates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          handleStatusUpdates: (client: Client) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method initializeDeserializer

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method initializeSerializer

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method listen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                listen: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: (err?: unknown, ...optionalParams: unknown[]) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  start: (callback: (err?: unknown, ...optionalParams: unknown[]) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ServerRedis

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ServerRedis extends Server implements CustomTransportStrategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property transportId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly transportId: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method bindEvents

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            close: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method createRedisClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              createRedisClient: () => Redis;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method createRetryStrategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                createRetryStrategy: (times: number) => undefined | number | void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getClientOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getClientOptions: () => Partial<RedisOptions['options']>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getMessageHandler

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getPublisher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getPublisher: (pub: Redis, pattern: any, id: string) => (response: any) => 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: string | any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pub: Redis,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pattern: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method listen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                listen: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: (err?: unknown, ...optionalParams: unknown[]) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method parseMessage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    me