@nestjs/microservices

  • Version 8.4.7
  • Published
  • 377 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: {
                          interceptors?: ((options: any, nextCall: (options: any) => any) => any)[];
                          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;
                          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: {
                                  interceptors?: ((options: any, nextCall: (options: any) => any) => any)[];
                                  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;
                                  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<ConsumerSubscribeTopic, 'topic'>;
                                                                        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 logger

                                                                                      protected logger: Logger;

                                                                                        property options

                                                                                        protected readonly options: {
                                                                                        postfixId?: string;
                                                                                        client?: KafkaConfig;
                                                                                        consumer?: ConsumerConfig;
                                                                                        run?: Omit<ConsumerRunConfig, 'eachBatch' | 'eachMessage'>;
                                                                                        subscribe?: Omit<ConsumerSubscribeTopic, 'topic'>;
                                                                                        producer?: ProducerConfig;
                                                                                        send?: Omit<ProducerRecord, 'topic' | 'messages'>;
                                                                                        serializer?: Serializer<any, any>;
                                                                                        deserializer?: Deserializer<any, any>;
                                                                                        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
                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                              interceptors?: ((
                                                                                                                                                                                                                              options: any,
                                                                                                                                                                                                                              nextCall: (options: any) => any
                                                                                                                                                                                                                              ) => any)[];
                                                                                                                                                                                                                              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;
                                                                                                                                                                                                                              loader?: {
                                                                                                                                                                                                                              keepCase?: boolean;
                                                                                                                                                                                                                              alternateCommentMode?: boolean;
                                                                                                                                                                                                                              longs?: Function;
                                                                                                                                                                                                                              enums?: Function;
                                                                                                                                                                                                                              bytes?: Function;
                                                                                                                                                                                                                              defaults?: boolean;
                                                                                                                                                                                                                              arrays?: boolean;
                                                                                                                                                                                                                              objects?: boolean;
                                                                                                                                                                                                                              oneofs?: boolean;
                                                                                                                                                                                                                              json?: boolean;
                                                                                                                                                                                                                              includeDirs?: string[];
                                                                                                                                                                                                                              };
                                                                                                                                                                                                                              }
                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                              postfixId?: string;
                                                                                                                                                                                                                              client?: KafkaConfig;
                                                                                                                                                                                                                              consumer?: ConsumerConfig;
                                                                                                                                                                                                                              run?: Omit<ConsumerRunConfig, 'eachBatch' | 'eachMessage'>;
                                                                                                                                                                                                                              subscribe?: Omit<ConsumerSubscribeTopic, 'topic'>;
                                                                                                                                                                                                                              producer?: ProducerConfig;
                                                                                                                                                                                                                              send?: Omit<ProducerRecord, 'topic' | 'messages'>;
                                                                                                                                                                                                                              serializer?: Serializer<any, any>;
                                                                                                                                                                                                                              deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                              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;
                                                                                                                                                                                                                              }
                                                                                                                                                                                                                              | ({
                                                                                                                                                                                                                              url?: string;
                                                                                                                                                                                                                              retryAttempts?: number;
                                                                                                                                                                                                                              retryDelay?: number;
                                                                                                                                                                                                                              serializer?: Serializer<any, any>;
                                                                                                                                                                                                                              deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                              } & ClientOpts)
                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                              host?: string;
                                                                                                                                                                                                                              port?: number;
                                                                                                                                                                                                                              serializer?: Serializer<any, any>;
                                                                                                                                                                                                                              deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                              socketClass?: Type<TcpSocket>;
                                                                                                                                                                                                                              }
                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                              urls?: string[] | RmqUrl[];
                                                                                                                                                                                                                              queue?: string;
                                                                                                                                                                                                                              prefetchCount?: number;
                                                                                                                                                                                                                              isGlobalPrefetchCount?: boolean;
                                                                                                                                                                                                                              queueOptions?: any;
                                                                                                                                                                                                                              socketOptions?: any;
                                                                                                                                                                                                                              noAck?: boolean;
                                                                                                                                                                                                                              serializer?: Serializer<any, any>;
                                                                                                                                                                                                                              deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                              replyQueue?: string;
                                                                                                                                                                                                                              persistent?: boolean;
                                                                                                                                                                                                                              headers?: Record<string, string>;
                                                                                                                                                                                                                              },
                                                                                                                                                                                                                              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: {
                                                                                                                                                                                                                                                    url?: string;
                                                                                                                                                                                                                                                    retryAttempts?: number;
                                                                                                                                                                                                                                                    retryDelay?: number;
                                                                                                                                                                                                                                                    serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                    deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                    } & ClientOpts
                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                      property connection

                                                                                                                                                                                                                                                      protected connection: Promise<any>;

                                                                                                                                                                                                                                                        property isExplicitlyTerminated

                                                                                                                                                                                                                                                        protected isExplicitlyTerminated: boolean;

                                                                                                                                                                                                                                                          property logger

                                                                                                                                                                                                                                                          protected readonly logger: Logger;

                                                                                                                                                                                                                                                            property options

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

                                                                                                                                                                                                                                                              property pubClient

                                                                                                                                                                                                                                                              protected pubClient: RedisClient;

                                                                                                                                                                                                                                                                property subClient

                                                                                                                                                                                                                                                                protected subClient: RedisClient;

                                                                                                                                                                                                                                                                  property subscriptionsCount

                                                                                                                                                                                                                                                                  protected readonly subscriptionsCount: Map<string, number>;

                                                                                                                                                                                                                                                                    property url

                                                                                                                                                                                                                                                                    protected readonly url: string;

                                                                                                                                                                                                                                                                      method close

                                                                                                                                                                                                                                                                      close: () => void;

                                                                                                                                                                                                                                                                        method connect

                                                                                                                                                                                                                                                                        connect: () => Promise<any>;

                                                                                                                                                                                                                                                                          method createClient

                                                                                                                                                                                                                                                                          createClient: (error$: Subject<Error>) => RedisClient;

                                                                                                                                                                                                                                                                            method createResponseCallback

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

                                                                                                                                                                                                                                                                              method createRetryStrategy

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

                                                                                                                                                                                                                                                                                method dispatchEvent

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

                                                                                                                                                                                                                                                                                  method getClientOptions

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

                                                                                                                                                                                                                                                                                    method getReplyPattern

                                                                                                                                                                                                                                                                                    getReplyPattern: (pattern: string) => string;

                                                                                                                                                                                                                                                                                      method getRequestPattern

                                                                                                                                                                                                                                                                                      getRequestPattern: (pattern: string) => string;

                                                                                                                                                                                                                                                                                        method handleError

                                                                                                                                                                                                                                                                                        handleError: (client: RedisClient) => void;

                                                                                                                                                                                                                                                                                          method publish

                                                                                                                                                                                                                                                                                          protected publish: (
                                                                                                                                                                                                                                                                                          partialPacket: ReadPacket,
                                                                                                                                                                                                                                                                                          callback: (packet: WritePacket) => any
                                                                                                                                                                                                                                                                                          ) => () => 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;
                                                                                                                                                                                                                                                                                                serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                replyQueue?: string;
                                                                                                                                                                                                                                                                                                persistent?: boolean;
                                                                                                                                                                                                                                                                                                headers?: Record<string, string>;
                                                                                                                                                                                                                                                                                                });

                                                                                                                                                                                                                                                                                                  property channel

                                                                                                                                                                                                                                                                                                  protected channel: any;

                                                                                                                                                                                                                                                                                                    property client

                                                                                                                                                                                                                                                                                                    protected client: any;

                                                                                                                                                                                                                                                                                                      property connection

                                                                                                                                                                                                                                                                                                      protected connection: Promise<any>;

                                                                                                                                                                                                                                                                                                        property logger

                                                                                                                                                                                                                                                                                                        protected readonly logger: Logger;

                                                                                                                                                                                                                                                                                                          property options

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

                                                                                                                                                                                                                                                                                                            property persistent

                                                                                                                                                                                                                                                                                                            protected persistent: boolean;

                                                                                                                                                                                                                                                                                                              property queue

                                                                                                                                                                                                                                                                                                              protected queue: string;

                                                                                                                                                                                                                                                                                                                property queueOptions

                                                                                                                                                                                                                                                                                                                protected queueOptions: 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: any) => Promise<void>;

                                                                                                                                                                                                                                                                                                                              method createChannel

                                                                                                                                                                                                                                                                                                                              createChannel: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                method createClient

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

                                                                                                                                                                                                                                                                                                                                  method dispatchEvent

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

                                                                                                                                                                                                                                                                                                                                    method handleDisconnectError

                                                                                                                                                                                                                                                                                                                                    handleDisconnectError: (client: any) => void;

                                                                                                                                                                                                                                                                                                                                      method handleError

                                                                                                                                                                                                                                                                                                                                      handleError: (client: any) => void;

                                                                                                                                                                                                                                                                                                                                        method handleMessage

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

                                                                                                                                                                                                                                                                                                                                          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 publish

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

                                                                                                                                                                                                                                                                                                                                                  method setupChannel

                                                                                                                                                                                                                                                                                                                                                  setupChannel: (channel: any, 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>;
                                                                                                                                                                                                                                                                                                                                                            socketClass?: Type<TcpSocket>;
                                                                                                                                                                                                                                                                                                                                                            });

                                                                                                                                                                                                                                                                                                                                                              property connection

                                                                                                                                                                                                                                                                                                                                                              protected connection: Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                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 getMessage

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

                                                                                                                                                                                                                                                                                                                                                                                            method getPartition

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

                                                                                                                                                                                                                                                                                                                                                                                            method getTopic

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

                                                                                                                                                                                                                                                                                                                                                                                            class KafkaParser

                                                                                                                                                                                                                                                                                                                                                                                            class KafkaParser {}

                                                                                                                                                                                                                                                                                                                                                                                              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 MqttContext

                                                                                                                                                                                                                                                                                                                                                                                                                    class MqttContext extends BaseRpcContext<MqttContextArgs> {}

                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(args: MqttContextArgs);

                                                                                                                                                                                                                                                                                                                                                                                                                        method getPacket

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

                                                                                                                                                                                                                                                                                                                                                                                                                        method getTopic

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

                                                                                                                                                                                                                                                                                                                                                                                                                        class 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 implements INestMicroservice {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 listenAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      listenAsync: () => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method registerListeners

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        registerListeners: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method registerModules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          registerModules: () => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method setIsInitHookCalled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setIsInitHookCalled: (isInitHookCalled: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method setIsInitialized

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setIsInitialized: (isInitialized: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method setIsTerminated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setIsTerminated: (isTerminated: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method useGlobalFilters

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method useGlobalGuards

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method useGlobalInterceptors

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method useGlobalPipes

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method useWebSocketAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          useWebSocketAdapter: (adapter: 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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interceptors?: ((
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nextCall: (options: any) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => any)[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              loader?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              keepCase?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              alternateCommentMode?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              longs?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enums?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bytes?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              defaults?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              arrays?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              objects?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              oneofs?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              json?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              includeDirs?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              postfixId?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              client?: KafkaConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              consumer?: ConsumerConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              run?: Omit<ConsumerRunConfig, 'eachBatch' | 'eachMessage'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              subscribe?: Omit<ConsumerSubscribeTopic, 'topic'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              producer?: ProducerConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              send?: Omit<ProducerRecord, 'topic' | 'messages'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              url?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              retryAttempts?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              retryDelay?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              } & ClientOpts)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              urls?: string[] | RmqUrl[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              queue?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              prefetchCount?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isGlobalPrefetchCount?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              queueOptions?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              socketOptions?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              noAck?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              replyQueue?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              persistent?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              headers?: Record<string, string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              host?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              port?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              retryAttempts?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              retryDelay?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interceptors?: ((options: any, nextCall: (options: any) => any) => any)[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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: () => 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>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ServerKafka

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ServerKafka extends Server implements CustomTransportStrategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 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: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        url?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        retryAttempts?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        retryDelay?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } & ClientOpts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property transportId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly transportId: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method bindEvents

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              close: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method createRedisClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                createRedisClient: () => RedisClient;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method createRetryStrategy

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getClientOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getClientOptions: () => Partial<ClientOpts>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getMessageHandler

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getPublisher

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getReplyPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getReplyPattern: (pattern: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getRequestPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getRequestPattern: (pattern: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method handleError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              handleError: (stream: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method handleMessage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method listen

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method parseMessage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method start

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ServerRMQ

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ServerRMQ extends Server implements CustomTransportStrategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          urls?: string[] | Rm