@nestjs/microservices/listeners-controller.d.ts

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

import { Observable, ObservedValueOf } from 'rxjs';
import { IClientProxyFactory } from './client/client-proxy-factory.js';
import { ClientsContainer } from './container.js';
import { ExceptionFiltersContext } from './context/exception-filters-context.js';
import { RpcContextCreator } from './context/rpc-context-creator.js';
import { Transport } from './enums/index.js';
import { MessageHandler, PatternMetadata } from './interfaces/index.js';
import { EventOrMessageListenerDefinition } from './listener-metadata-explorer.js';
import { Server } from './server/server.js';
import { type Controller } from '@nestjs/common/internal';
import { type NestContainer, type GraphInspector } from '@nestjs/core';
import { type Injector, type InstanceWrapper, type Module } from '@nestjs/core/internal';
export declare class ListenersController {
    private readonly clientsContainer;
    private readonly contextCreator;
    private readonly container;
    private readonly injector;
    private readonly clientFactory;
    private readonly exceptionFiltersContext;
    private readonly graphInspector;
    private readonly metadataExplorer;
    private readonly exceptionFiltersCache;
    constructor(clientsContainer: ClientsContainer, contextCreator: RpcContextCreator, container: NestContainer, injector: Injector, clientFactory: IClientProxyFactory, exceptionFiltersContext: ExceptionFiltersContext, graphInspector: GraphInspector);
    registerPatternHandlers(instanceWrapper: InstanceWrapper<Controller>, serverInstance: Server, moduleKey: string): void;
    insertEntrypointDefinition(instanceWrapper: InstanceWrapper, definition: EventOrMessageListenerDefinition, transportId: Transport | symbol): void;
    forkJoinHandlersIfAttached(currentReturnValue: Promise<unknown> | Observable<unknown>, originalArgs: unknown[], handlerRef: MessageHandler): Observable<unknown> | Promise<unknown>;
    assignClientsToProperties(instance: Controller): void;
    assignClientToInstance<T = any>(instance: Controller, property: string, client: T): void;
    createRequestScopedHandler(wrapper: InstanceWrapper, pattern: PatternMetadata, moduleRef: Module, moduleKey: string, methodKey: string, defaultCallMetadata?: Record<string, any>, isEventHandler?: boolean): MessageHandler<any, any, any>;
    private getContextId;
    transformToObservable<T>(resultOrDeferred: Observable<T> | Promise<T>): Observable<T>;
    transformToObservable<T>(resultOrDeferred: T): never extends Observable<ObservedValueOf<T>> ? Observable<T> : Observable<ObservedValueOf<T>>;
}