@nestjs/microservices

  • Version 8.0.6
  • Published
  • 352 kB
  • 3 dependencies
  • MIT license

Install

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

Overview

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

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Variables

variable CONTEXT

const CONTEXT: string;

    variable GrpcService

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

    Functions

    function Client

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

      Parameter metadata

      optional client metadata

    function createGrpcMethodMetadata

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

      function Ctx

      Ctx: () => ParameterDecorator;

        function EventPattern

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

        function GrpcMethod

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

        function GrpcStreamCall

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

          Parameter service

          String parameter reflecting the name of service definition from proto file

        • Parameter service

          String parameter reflecting the name of service definition from proto file

          Parameter method

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

        function GrpcStreamMethod

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

          Parameter service

          String parameter reflecting the name of service definition from proto file

        • Parameter service

          String parameter reflecting the name of service definition from proto file

          Parameter method

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

        function KafkaLogger

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

          function MessagePattern

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

          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 BaseRpcExceptionFilter

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

            method catch

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

              method handleUnknownError

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

                method isError

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

                  class ClientGrpcProxy

                  class ClientGrpcProxy extends ClientProxy implements ClientGrpc {}

                    constructor

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

                      property clients

                      protected readonly clients: Map<string, any>;

                        property grpcClients

                        protected grpcClients: any[];

                          property logger

                          protected readonly logger: any;

                            property options

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

                              property url

                              protected readonly url: string;

                                method close

                                close: () => void;

                                  method connect

                                  connect: () => Promise<any>;

                                    method createClientByServiceName

                                    createClientByServiceName: (name: string) => any;

                                      method createClients

                                      createClients: () => any[];

                                        method createServiceMethod

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

                                          method createStreamServiceMethod

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

                                            method createUnaryServiceMethod

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

                                              method dispatchEvent

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

                                                method getClient

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

                                                  method getClientByServiceName

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

                                                    method getKeepaliveOptions

                                                    getKeepaliveOptions: () => {};

                                                      method getService

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

                                                        method loadProto

                                                        loadProto: () => any;

                                                          method lookupPackage

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

                                                            method publish

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

                                                              method send

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

                                                                class ClientKafka

                                                                class ClientKafka extends ClientProxy {}

                                                                  constructor

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

                                                                    property brokers

                                                                    protected brokers: string[] | BrokersFunction;

                                                                      property client

                                                                      protected client: Kafka;

                                                                        property clientId

                                                                        protected clientId: string;

                                                                          property consumer

                                                                          protected consumer: Consumer;

                                                                            property consumerAssignments

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

                                                                              property groupId

                                                                              protected groupId: string;

                                                                                property logger

                                                                                protected logger: any;

                                                                                  property options

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

                                                                                    property parser

                                                                                    protected parser: KafkaParser;

                                                                                      property producer

                                                                                      protected producer: Producer;

                                                                                        property responsePatterns

                                                                                        protected responsePatterns: string[];

                                                                                          method bindTopics

                                                                                          bindTopics: () => Promise<void>;

                                                                                            method close

                                                                                            close: () => Promise<void>;

                                                                                              method connect

                                                                                              connect: () => Promise<Producer>;

                                                                                                method createClient

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

                                                                                                  method createResponseCallback

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

                                                                                                    method dispatchEvent

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

                                                                                                      method getConsumerAssignments

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

                                                                                                        method getReplyTopicPartition

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

                                                                                                          method getResponsePatternName

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

                                                                                                            method initializeDeserializer

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

                                                                                                              method initializeSerializer

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

                                                                                                                method publish

                                                                                                                protected publish: (
                                                                                                                partialPacket: ReadPacket,
                                                                                                                callback: (packet: WritePacket) => any
                                                                                                                ) => () => 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>;
                                                                                                                        }
                                                                                                                        );

                                                                                                                          property connection

                                                                                                                          protected connection: Promise<any>;

                                                                                                                            property logger

                                                                                                                            protected readonly logger: any;

                                                                                                                              property mqttClient

                                                                                                                              protected mqttClient: MqttClient;

                                                                                                                                property options

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

                                                                                                                                  property subscriptionsCount

                                                                                                                                  protected readonly subscriptionsCount: Map<string, number>;

                                                                                                                                    property url

                                                                                                                                    protected readonly url: string;

                                                                                                                                      method close

                                                                                                                                      close: () => void;

                                                                                                                                        method connect

                                                                                                                                        connect: () => Promise<any>;

                                                                                                                                          method createClient

                                                                                                                                          createClient: () => MqttClient;

                                                                                                                                            method createResponseCallback

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

                                                                                                                                              method dispatchEvent

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

                                                                                                                                                method getRequestPattern

                                                                                                                                                getRequestPattern: (pattern: string) => string;

                                                                                                                                                  method getResponsePattern

                                                                                                                                                  getResponsePattern: (pattern: string) => string;

                                                                                                                                                    method handleError

                                                                                                                                                    handleError: (client: MqttClient) => void;

                                                                                                                                                      method mergeCloseEvent

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

                                                                                                                                                        method publish

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

                                                                                                                                                          method unsubscribeFromChannel

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

                                                                                                                                                            class ClientNats

                                                                                                                                                            class ClientNats extends ClientProxy {}

                                                                                                                                                              constructor

                                                                                                                                                              constructor(options: {
                                                                                                                                                              [key: string]: any;
                                                                                                                                                              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: any;

                                                                                                                                                                  property natsClient

                                                                                                                                                                  protected natsClient: Client;

                                                                                                                                                                    property options

                                                                                                                                                                    protected readonly options: {
                                                                                                                                                                    [key: string]: any;
                                                                                                                                                                    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 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
                                                                                                                                                                                                      ) => any;

                                                                                                                                                                                                        method createObserver

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

                                                                                                                                                                                                          method dispatchEvent

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

                                                                                                                                                                                                            method emit

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

                                                                                                                                                                                                              method getOptionsProp

                                                                                                                                                                                                              protected getOptionsProp: <
                                                                                                                                                                                                              T extends
                                                                                                                                                                                                              | {
                                                                                                                                                                                                              url?: string;
                                                                                                                                                                                                              maxSendMessageLength?: number;
                                                                                                                                                                                                              maxReceiveMessageLength?: number;
                                                                                                                                                                                                              maxMetadataSize?: number;
                                                                                                                                                                                                              keepalive?: {
                                                                                                                                                                                                              keepaliveTimeMs?: number;
                                                                                                                                                                                                              keepaliveTimeoutMs?: number;
                                                                                                                                                                                                              keepalivePermitWithoutCalls?: number;
                                                                                                                                                                                                              http2MaxPingsWithoutData?: number;
                                                                                                                                                                                                              http2MinTimeBetweenPingsMs?: number;
                                                                                                                                                                                                              http2MinPingIntervalWithoutDataMs?: number;
                                                                                                                                                                                                              http2MaxPingStrikes?: number;
                                                                                                                                                                                                              };
                                                                                                                                                                                                              channelOptions?: ChannelOptions;
                                                                                                                                                                                                              credentials?: any;
                                                                                                                                                                                                              protoPath: string | string[];
                                                                                                                                                                                                              package: string | string[];
                                                                                                                                                                                                              protoLoader?: string;
                                                                                                                                                                                                              loader?: {
                                                                                                                                                                                                              keepCase?: boolean;
                                                                                                                                                                                                              alternateCommentMode?: boolean;
                                                                                                                                                                                                              longs?: Function;
                                                                                                                                                                                                              enums?: Function;
                                                                                                                                                                                                              bytes?: Function;
                                                                                                                                                                                                              defaults?: boolean;
                                                                                                                                                                                                              arrays?: boolean;
                                                                                                                                                                                                              objects?: boolean;
                                                                                                                                                                                                              oneofs?: boolean;
                                                                                                                                                                                                              json?: boolean;
                                                                                                                                                                                                              includeDirs?: string[];
                                                                                                                                                                                                              };
                                                                                                                                                                                                              }
                                                                                                                                                                                                              | {
                                                                                                                                                                                                              postfixId?: string;
                                                                                                                                                                                                              client?: KafkaConfig;
                                                                                                                                                                                                              consumer?: ConsumerConfig;
                                                                                                                                                                                                              run?: Omit<ConsumerRunConfig, 'eachBatch' | 'eachMessage'>;
                                                                                                                                                                                                              subscribe?: Omit<ConsumerSubscribeTopic, 'topic'>;
                                                                                                                                                                                                              producer?: ProducerConfig;
                                                                                                                                                                                                              send?: Omit<ProducerRecord, 'topic' | 'messages'>;
                                                                                                                                                                                                              serializer?: Serializer<any, any>;
                                                                                                                                                                                                              deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                              parser?: KafkaParserConfig;
                                                                                                                                                                                                              }
                                                                                                                                                                                                              | (MqttClientOptions & {
                                                                                                                                                                                                              url?: string;
                                                                                                                                                                                                              serializer?: Serializer<any, any>;
                                                                                                                                                                                                              deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                              })
                                                                                                                                                                                                              | {
                                                                                                                                                                                                              [key: string]: any;
                                                                                                                                                                                                              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>;
                                                                                                                                                                                                              }
                                                                                                                                                                                                              | {
                                                                                                                                                                                                              urls?: string[] | RmqUrl[];
                                                                                                                                                                                                              queue?: string;
                                                                                                                                                                                                              prefetchCount?: number;
                                                                                                                                                                                                              isGlobalPrefetchCount?: boolean;
                                                                                                                                                                                                              queueOptions?: any;
                                                                                                                                                                                                              socketOptions?: any;
                                                                                                                                                                                                              noAck?: boolean;
                                                                                                                                                                                                              serializer?: Serializer<any, any>;
                                                                                                                                                                                                              deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                              replyQueue?: string;
                                                                                                                                                                                                              persistent?: boolean;
                                                                                                                                                                                                              },
                                                                                                                                                                                                              K extends keyof T
                                                                                                                                                                                                              >(
                                                                                                                                                                                                              obj: T,
                                                                                                                                                                                                              prop: K,
                                                                                                                                                                                                              defaultValue?: T[K]
                                                                                                                                                                                                              ) => T[K];

                                                                                                                                                                                                                method initializeDeserializer

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

                                                                                                                                                                                                                  method initializeSerializer

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

                                                                                                                                                                                                                    method normalizePattern

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

                                                                                                                                                                                                                      method publish

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

                                                                                                                                                                                                                        method send

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

                                                                                                                                                                                                                          method serializeError

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

                                                                                                                                                                                                                            method serializeResponse

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

                                                                                                                                                                                                                              class ClientProxyFactory

                                                                                                                                                                                                                              class ClientProxyFactory {}

                                                                                                                                                                                                                                method create

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

                                                                                                                                                                                                                                  class ClientRedis

                                                                                                                                                                                                                                  class ClientRedis extends ClientProxy {}

                                                                                                                                                                                                                                    constructor

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

                                                                                                                                                                                                                                      property connection

                                                                                                                                                                                                                                      protected connection: Promise<any>;

                                                                                                                                                                                                                                        property isExplicitlyTerminated

                                                                                                                                                                                                                                        protected isExplicitlyTerminated: boolean;

                                                                                                                                                                                                                                          property logger

                                                                                                                                                                                                                                          protected readonly logger: any;

                                                                                                                                                                                                                                            property options

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

                                                                                                                                                                                                                                              property pubClient

                                                                                                                                                                                                                                              protected pubClient: RedisClient;

                                                                                                                                                                                                                                                property subClient

                                                                                                                                                                                                                                                protected subClient: RedisClient;

                                                                                                                                                                                                                                                  property subscriptionsCount

                                                                                                                                                                                                                                                  protected readonly subscriptionsCount: Map<string, number>;

                                                                                                                                                                                                                                                    property url

                                                                                                                                                                                                                                                    protected readonly url: string;

                                                                                                                                                                                                                                                      method close

                                                                                                                                                                                                                                                      close: () => void;

                                                                                                                                                                                                                                                        method connect

                                                                                                                                                                                                                                                        connect: () => Promise<any>;

                                                                                                                                                                                                                                                          method createClient

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

                                                                                                                                                                                                                                                            method createResponseCallback

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

                                                                                                                                                                                                                                                              method createRetryStrategy

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

                                                                                                                                                                                                                                                                method dispatchEvent

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

                                                                                                                                                                                                                                                                  method getClientOptions

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

                                                                                                                                                                                                                                                                    method getReplyPattern

                                                                                                                                                                                                                                                                    getReplyPattern: (pattern: string) => string;

                                                                                                                                                                                                                                                                      method getRequestPattern

                                                                                                                                                                                                                                                                      getRequestPattern: (pattern: string) => string;

                                                                                                                                                                                                                                                                        method handleError

                                                                                                                                                                                                                                                                        handleError: (client: RedisClient) => void;

                                                                                                                                                                                                                                                                          method publish

                                                                                                                                                                                                                                                                          protected publish: (
                                                                                                                                                                                                                                                                          partialPacket: ReadPacket,
                                                                                                                                                                                                                                                                          callback: (packet: WritePacket) => any
                                                                                                                                                                                                                                                                          ) => () => 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;
                                                                                                                                                                                                                                                                                });

                                                                                                                                                                                                                                                                                  property channel

                                                                                                                                                                                                                                                                                  protected channel: any;

                                                                                                                                                                                                                                                                                    property client

                                                                                                                                                                                                                                                                                    protected client: any;

                                                                                                                                                                                                                                                                                      property connection

                                                                                                                                                                                                                                                                                      protected connection: Promise<any>;

                                                                                                                                                                                                                                                                                        property logger

                                                                                                                                                                                                                                                                                        protected readonly logger: any;

                                                                                                                                                                                                                                                                                          property options

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

                                                                                                                                                                                                                                                                                            property persistent

                                                                                                                                                                                                                                                                                            protected persistent: boolean;

                                                                                                                                                                                                                                                                                              property queue

                                                                                                                                                                                                                                                                                              protected queue: string;

                                                                                                                                                                                                                                                                                                property queueOptions

                                                                                                                                                                                                                                                                                                protected queueOptions: any;

                                                                                                                                                                                                                                                                                                  property replyQueue

                                                                                                                                                                                                                                                                                                  protected replyQueue: string;

                                                                                                                                                                                                                                                                                                    property responseEmitter

                                                                                                                                                                                                                                                                                                    protected responseEmitter: any;

                                                                                                                                                                                                                                                                                                      property urls

                                                                                                                                                                                                                                                                                                      protected urls: string[] | RmqUrl[];

                                                                                                                                                                                                                                                                                                        method close

                                                                                                                                                                                                                                                                                                        close: () => void;

                                                                                                                                                                                                                                                                                                          method connect

                                                                                                                                                                                                                                                                                                          connect: () => Promise<any>;

                                                                                                                                                                                                                                                                                                            method consumeChannel

                                                                                                                                                                                                                                                                                                            consumeChannel: () => void;

                                                                                                                                                                                                                                                                                                              method createChannel

                                                                                                                                                                                                                                                                                                              createChannel: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                method createClient

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

                                                                                                                                                                                                                                                                                                                  method dispatchEvent

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

                                                                                                                                                                                                                                                                                                                    method handleDisconnectError

                                                                                                                                                                                                                                                                                                                    handleDisconnectError: (client: any) => void;

                                                                                                                                                                                                                                                                                                                      method handleError

                                                                                                                                                                                                                                                                                                                      handleError: (client: any) => void;

                                                                                                                                                                                                                                                                                                                        method handleMessage

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

                                                                                                                                                                                                                                                                                                                          method mergeDisconnectEvent

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

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

                                                                                                                                                                                                                                                                                                                                    method registerAsync

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

                                                                                                                                                                                                                                                                                                                                      class ClientTCP

                                                                                                                                                                                                                                                                                                                                      class ClientTCP extends ClientProxy {}

                                                                                                                                                                                                                                                                                                                                        constructor

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

                                                                                                                                                                                                                                                                                                                                          property connection

                                                                                                                                                                                                                                                                                                                                          protected connection: Promise<any>;

                                                                                                                                                                                                                                                                                                                                            method bindEvents

                                                                                                                                                                                                                                                                                                                                            bindEvents: (socket: JsonSocket) => void;

                                                                                                                                                                                                                                                                                                                                              method close

                                                                                                                                                                                                                                                                                                                                              close: () => void;

                                                                                                                                                                                                                                                                                                                                                method connect

                                                                                                                                                                                                                                                                                                                                                connect: () => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                  method createSocket

                                                                                                                                                                                                                                                                                                                                                  createSocket: () => JsonSocket;

                                                                                                                                                                                                                                                                                                                                                    method dispatchEvent

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

                                                                                                                                                                                                                                                                                                                                                      method handleClose

                                                                                                                                                                                                                                                                                                                                                      handleClose: () => void;

                                                                                                                                                                                                                                                                                                                                                        method handleError

                                                                                                                                                                                                                                                                                                                                                        handleError: (err: any) => void;

                                                                                                                                                                                                                                                                                                                                                          method handleResponse

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

                                                                                                                                                                                                                                                                                                                                                            method publish

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

                                                                                                                                                                                                                                                                                                                                                              class JsonSocket

                                                                                                                                                                                                                                                                                                                                                              class JsonSocket {}

                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                constructor(socket: any);

                                                                                                                                                                                                                                                                                                                                                                  property netSocket

                                                                                                                                                                                                                                                                                                                                                                  readonly netSocket: any;

                                                                                                                                                                                                                                                                                                                                                                    property socket

                                                                                                                                                                                                                                                                                                                                                                    readonly socket: any;

                                                                                                                                                                                                                                                                                                                                                                      method connect

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

                                                                                                                                                                                                                                                                                                                                                                        method end

                                                                                                                                                                                                                                                                                                                                                                        end: () => this;

                                                                                                                                                                                                                                                                                                                                                                          method on

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

                                                                                                                                                                                                                                                                                                                                                                            method once

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

                                                                                                                                                                                                                                                                                                                                                                              method sendMessage

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

                                                                                                                                                                                                                                                                                                                                                                                class KafkaContext

                                                                                                                                                                                                                                                                                                                                                                                class KafkaContext extends BaseRpcContext<KafkaContextArgs> {}

                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                  constructor(args: KafkaContextArgs);

                                                                                                                                                                                                                                                                                                                                                                                    method getMessage

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

                                                                                                                                                                                                                                                                                                                                                                                    method getPartition

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

                                                                                                                                                                                                                                                                                                                                                                                    method getTopic

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

                                                                                                                                                                                                                                                                                                                                                                                    class KafkaParser

                                                                                                                                                                                                                                                                                                                                                                                    class KafkaParser {}

                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                      constructor(config?: KafkaParserConfig);

                                                                                                                                                                                                                                                                                                                                                                                        property keepBinary

                                                                                                                                                                                                                                                                                                                                                                                        protected readonly keepBinary: boolean;

                                                                                                                                                                                                                                                                                                                                                                                          method decode

                                                                                                                                                                                                                                                                                                                                                                                          decode: (value: any) => 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 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 NestMicroservice

                                                                                                                                                                                                                                                                                                                                                                                                                    class NestMicroservice extends NestApplicationContext implements INestMicroservice {}

                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                          class RedisContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                          class RedisContext extends BaseRpcContext<RedisContextArgs> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(args: RedisContextArgs);

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getChannel

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                              class RmqContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                              class RmqContext extends BaseRpcContext<RmqContextArgs> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(args: RmqContextArgs);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getChannelRef

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getMessage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getPattern

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class RpcException

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class RpcException extends Error {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(error: string | object);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getError: () => string | object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method initMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        initMessage: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Server

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          abstract class Server {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property deserializer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected deserializer: ConsumerDeserializer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property logger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected readonly logger: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property messageHandlers

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property serializer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected serializer: ConsumerSerializer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method addHandler

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getHandlerByPattern

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getHandlers

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getOptionsProp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getOptionsProp: <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          T extends
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          url?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          maxSendMessageLength?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          maxReceiveMessageLength?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          maxMetadataSize?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          keepalive?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          keepaliveTimeMs?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          keepaliveTimeoutMs?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          keepalivePermitWithoutCalls?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          http2MaxPingsWithoutData?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          http2MinTimeBetweenPingsMs?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          http2MinPingIntervalWithoutDataMs?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          http2MaxPingStrikes?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          channelOptions?: ChannelOptions;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          credentials?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protoPath: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          package: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protoLoader?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          loader?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          keepCase?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          alternateCommentMode?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          longs?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          enums?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bytes?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          defaults?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arrays?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          objects?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          oneofs?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          json?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          includeDirs?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          postfixId?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          client?: KafkaConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          consumer?: ConsumerConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          run?: Omit<ConsumerRunConfig, 'eachBatch' | 'eachMessage'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          subscribe?: Omit<ConsumerSubscribeTopic, 'topic'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          producer?: ProducerConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          send?: Omit<ProducerRecord, 'topic' | 'messages'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parser?: KafkaParserConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | (MqttClientOptions & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          url?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          host?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          port?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          retryAttempts?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          retryDelay?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          serializer?: Serializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          deserializer?: Deserializer<any, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          K extends keyof T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          obj: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          prop: K,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          defaultValue?: T[K]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => T[K];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getRouteFromPattern

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter pattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              server pattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method handleError

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method handleEvent

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method initializeDeserializer

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method initializeSerializer

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method loadPackage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method normalizePattern

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method send

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method transformToObservable

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ServerGrpc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ServerGrpc extends Server implements CustomTransportStrategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property transportId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly transportId: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method addHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  addHandler: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  pattern: 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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property brokers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected brokers: string[] | BrokersFunction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property client

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected client: Kafka;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property clientId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected clientId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property consumer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected consumer: Consumer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property groupId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected groupId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property logger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected logger: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property options

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property transportId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly transportId: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method bindEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bindEvents: (mqttClient: MqttClient) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        close: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method createMqttClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createMqttClient: () => MqttClient;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getHandlerByPattern

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getMessageHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getMessageHandler: (pub: MqttClient) => Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getPublisher

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getReplyPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getReplyPattern: (pattern: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getRequestPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getRequestPattern: (pattern: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method handleError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      handleError: (stream: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method handleMessage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method listen

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method matchMqttPattern

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method parseMessage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method start

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class ServerNats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class ServerNats extends Server implements CustomTransportStrategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property channel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected channel: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property isGlobalPrefetchCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected readonly isGlobalPrefetchCount: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property options

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property prefetchCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected readonly prefetchCount: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property queue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected readonly queue: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property queueOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected readonly queueOptions: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property server

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected server: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property transportId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly transportId: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property urls

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      close: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method createClient

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method handleMessage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method listen

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method sendMessage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method setupChannel

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method start

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ServerTCP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ServerTCP extends Server implements CustomTransportStrategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property transportId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly transportId: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method bindHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bindHandler: (socket: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            close: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method handleClose

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method handleMessage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method listen

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class TcpContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class TcpContext extends BaseRpcContext<TcpContextArgs> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(args: TcpContextArgs);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getPattern

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getSocketRef

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ClientGrpc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ClientGrpc {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getClientByServiceName

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getService

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ClientsModuleOptionsFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ClientsModuleOptionsFactory {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method createClientOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ClientsProviderAsyncOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property extraProviders

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    extraProviders?: Provider[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property inject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      inject?: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string | symbol;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property useClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          useClass?: Type<ClientsModuleOptionsFactory>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property useExisting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            useExisting?: Type<ClientsModuleOptionsFactory>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property useFactory

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Closeable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Closeable {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  close: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CustomClientOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CustomClientOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property customClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      customClass: Type<ClientProxy>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: Record<string, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CustomStrategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CustomStrategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: {};

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              strategy: CustomTransportStrategy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CustomTransportStrategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CustomTransportStrategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property transportId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly transportId?: Transport;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    close: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method listen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      listen: (callback: (...optionalParams: unknown[]) => any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Deserializer

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method deserialize

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GrpcOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface GrpcOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property options

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property transport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                transport?: Transport.GRPC;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface KafkaOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface KafkaOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property options

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property transport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      transport?