moost/dist/index.d.ts

moost

import { useEventLogger } from '@wooksjs/event-core';
export { ContextInjector, EventLogger, THook, getContextInjector, replaceContextInjector, useAsyncEventContext, useEventLogger } from '@wooksjs/event-core';
import { TProvideRegistry, Infact, TReplaceRegistry, TProvideFn } from '@prostojs/infact';
export { TProvideRegistry, createProvideRegistry, createReplaceRegistry } from '@prostojs/infact';
import * as _prostojs_logger from '@prostojs/logger';
import { TConsoleBase, TProstoLoggerOptions, ProstoLogger } from '@prostojs/logger';
export { ProstoLogger, TConsoleBase } from '@prostojs/logger';
import { Hookable } from 'hookable';
import * as _prostojs_mate from '@prostojs/mate';
import { TMateParamMeta, Mate } from '@prostojs/mate';
export { Mate, TMateParamMeta, getConstructor, isConstructor } from '@prostojs/mate';
export { clearGlobalWooks, getGlobalWooks } from 'wooks';

type TAny = any;
type TAnyFn = (...a: TAny[]) => unknown;
type TObject = object;
type TFunction = Function;
type TClassConstructor<T = unknown> = new (...args: TAny[]) => T;
interface TEmpty {
}

declare function Circular<T = unknown>(resolver: () => TClassConstructor<T>): ParameterDecorator;

/**
 * Apply Multiple Decorators
 *
 * @param decorators - array of decorators
 * @returns
 */
declare function ApplyDecorators(...decorators: (MethodDecorator | ClassDecorator | ParameterDecorator | PropertyDecorator)[]): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
/**
 * ## Label
 * ### @Decorator
 * _Common purpose decorator that may be used by various adapters for various purposes_
 *
 * Stores Label metadata
 */
declare function Label(value: string): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
/**
 * ## Description
 * ### @Decorator
 * _Common purpose decorator that may be used by various adapters for various purposes_
 *
 * Stores Description metadata
 */
declare function Description(value: string): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
/**
 * ## Value
 * ### @Decorator
 * _Common purpose decorator that may be used by various adapters for various purposes_
 *
 * Stores Value metadata
 */
declare function Value(value: unknown): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
/**
 * ## Id
 * ### @Decorator
 * _Common purpose decorator that may be used by various adapters for various purposes_
 *
 * Stores Id metadata
 */
declare function Id(value: string): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
/**
 * ## Optional
 * ### @Decorator
 * _Common purpose decorator that may be used by various adapters for various purposes_
 *
 * Stores Optional metadata
 */
declare function Optional(): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
/**
 * ## Required
 * ### @Decorator
 * _Common purpose decorator that may be used by various adapters for various purposes_
 *
 * Stores Required metadata
 */
declare function Required(): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;

/**
 * ## Controller
 * ### @Decorator
 * Set Class as a Controller
 * @param prefix - define the prefix for all the paths of this controller
 */
declare function Controller(prefix?: string): ClassDecorator;
/**
 * ## ImportController
 * ### @Decorator
 * Attach sub-controller
 * @param controller - target controller (instance) to import
 * @param provide - provide registry for the target controller
 */
declare function ImportController(controller: TFunction | TObject, provide?: TProvideRegistry): ClassDecorator;
/**
 * ## ImportController
 * ### @Decorator
 * Attach sub-controller
 * @param prefix - redefine the prefix for all the paths of this controller
 * @param controller - point to a controller (instance) to import
 * @param provide - provide registry for the target controller
 */
declare function ImportController(prefix: string, controller: TFunction | TObject, provide?: TProvideRegistry): ClassDecorator;

/**
 * ## Inherit
 * ### @Decorator
 * Inherit metadata from super class
 * @returns
 */
declare const Inherit: () => MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;

interface TClassFunction<T extends TAnyFn = TAnyFn> {
    handler: T;
}
type TClassFunctionConstructor<T extends TAnyFn = TAnyFn> = new (...a: TAny[]) => TClassFunction<T>;
type TCallableClassFunction<T extends TAnyFn = TAnyFn> = T | TClassFunctionConstructor;

type TInterceptorBefore = (reply: (response: TAny) => void) => void | Promise<void>;
type TInterceptorAfter = (response: TAny, reply: (response: TAny) => void) => void | Promise<void>;
type TInterceptorOnError = (error: Error, reply: (response: TAny) => void) => void | Promise<void>;
interface TInterceptorFn {
    (before: (fn: TInterceptorBefore) => void, after: (fn: TInterceptorAfter) => void, onError: (fn: TInterceptorOnError) => void): unknown | Promise<unknown>;
    priority?: TInterceptorPriority;
    _name?: string;
}
declare enum TInterceptorPriority {
    BEFORE_ALL = 0,
    BEFORE_GUARD = 1,
    GUARD = 2,
    AFTER_GUARD = 3,
    INTERCEPTOR = 4,
    CATCH_ERROR = 5,
    AFTER_ALL = 6
}
/**
 * ## Intercept
 * ### @Decorator
 * Set interceptor
 * @param handler interceptor fn (use defineInterceptorFn)
 * @param priority interceptor priority
 * @returns
 */
declare function Intercept(handler: TCallableClassFunction<TInterceptorFn>, priority?: TInterceptorPriority, name?: string): ClassDecorator & MethodDecorator;

type TDecoratorLevel = 'CLASS' | 'METHOD' | 'PROP' | 'PARAM';

interface TInfactLoggingOptions {
    newInstance?: true | false | 'FOR_EVENT' | 'SINGLETON';
    warn?: true | false;
    error?: true | false;
}
declare function setInfactLoggingOptions(options: TInfactLoggingOptions): void;
declare function getMoostInfact(): Infact<TMoostMetadata<TEmpty>, TMoostMetadata<TEmpty>, TMoostParamsMetadata, TCustom>;
interface TCustom {
    pipes?: TPipeData[];
}
/**
 * Define global scope name to be used with `@InjectFromScope` and `@InjectScopeVars` decorators
 *
 * You can read scoped vars with `getInfactScopeVars`
 * @param name scope name
 * @param scopeVars key-value object as scoped vars
 */
declare function defineInfactScope<T extends object>(name: string | symbol, scopeVars: T): void;
/**
 * Read scoped vars defined with `defineInfactScope`
 * @param name scope name
 * @returns key-value object as scoped vars
 */
declare function getInfactScopeVars<T extends object>(name: string | symbol): T | undefined;
/**
 * Get Infact instance (used for Dependency Injections)
 */
declare function getNewMoostInfact(): Infact<TMoostMetadata<TEmpty>, TMoostMetadata<TEmpty>, TMoostParamsMetadata, TCustom>;

interface TPipeMetas<T extends TObject = TEmpty> {
    classMeta?: TMoostMetadata & T;
    methodMeta?: TMoostMetadata & T;
    propMeta?: TMoostMetadata & T;
    paramMeta?: TMoostParamsMetadata & T;
    targetMeta?: TMoostParamsMetadata & T;
    instance?: TObject;
    scopeId?: string | symbol;
    type: TFunction;
    index?: number;
    key: string | symbol;
    instantiate: <T extends TObject>(t: TClassConstructor<T>) => Promise<T>;
}
interface TPipeFn<T extends TObject = TEmpty> {
    (value: unknown, metas: TPipeMetas<T>, level: TDecoratorLevel): unknown | Promise<unknown>;
    priority?: TPipePriority;
}
declare enum TPipePriority {
    BEFORE_RESOLVE = 0,
    RESOLVE = 1,
    AFTER_RESOLVE = 2,
    BEFORE_TRANSFORM = 3,
    TRANSFORM = 4,
    AFTER_TRANSFORM = 5,
    BEFORE_VALIDATE = 6,
    VALIDATE = 7,
    AFTER_VALIDATE = 8
}
interface TPipeData {
    handler: TPipeFn;
    priority: TPipePriority;
}

declare const resolvePipe: TPipeFn<TEmpty>;

interface TMoostMetadata<H extends TObject = TEmpty> extends TCommonMetaFields, TCommonMoostMeta {
    requiredProps?: Array<string | symbol>;
    controller?: {
        prefix?: string;
    };
    importController?: Array<{
        prefix?: string;
        typeResolver?: TClassConstructor | (() => TClassConstructor | TObject | Promise<TClassConstructor | TObject>);
        provide?: TProvideRegistry;
    }>;
    properties?: Array<string | symbol>;
    injectable?: true | TInjectableScope;
    interceptors?: TInterceptorData[];
    handlers?: Array<TMoostHandler<H>>;
    returnType?: TFunction;
    provide?: TProvideRegistry;
    replace?: TReplaceRegistry;
    loggerTopic?: string;
    params: Array<TMateParamMeta & TMoostParamsMetadata>;
}
interface TMoostParamsMetadata extends TCommonMetaFields, TCommonMoostMeta {
    circular?: () => TAny;
    inject?: string | symbol | TClassConstructor;
    nullable?: boolean;
    paramSource?: string;
    paramName?: string;
    fromScope?: string | symbol;
}
type TInjectableScope = 'FOR_EVENT' | 'SINGLETON';
type TMoostHandler<T> = {
    type: string;
    path?: string;
} & T;
interface TInterceptorData {
    handler: TCallableClassFunction<TInterceptorFn>;
    priority: TInterceptorPriority;
    name: string;
}
declare function getMoostMate<Class extends TObject = TEmpty, Prop extends TObject = TEmpty, Param extends TObject = TEmpty>(): Mate<TMoostMetadata & Class & {
    params: Array<Param & TMateParamMeta>;
}, TMoostMetadata & Prop & {
    params: Array<Param & TMateParamMeta>;
}>;
interface TCommonMetaFields {
    id?: string;
    label?: string;
    value?: unknown;
    description?: string;
    optional?: boolean;
    required?: boolean;
}
interface TCommonMoostMeta {
    inherit?: boolean;
    pipes?: TPipeData[];
    resolver?: (metas: TPipeMetas<TAny>, level: TDecoratorLevel) => unknown;
    type?: TFunction;
}

/**
 * ## Injectable
 * ### @Decorator
 * Mark the Class as Injectable to enable it to be used in dependency injection
 * @param scope - Scope for injection ("FOR_EVENT" | "SINGLETON" | true)
 * FOR_EVENT - will create a new instance for each incoming request
 * SINGLETON | true - will create a new instance only once
 * @param label - field label
 */
declare function Injectable(scope?: true | TInjectableScope): ClassDecorator;

/**
 * Resolves event logger from event context
 * @param topic
 * @returns Resolver to '@wooksjs/event-core' (EventLogger)
 */
declare function InjectEventLogger(topic?: string): ParameterDecorator & PropertyDecorator;
/**
 * Resolves app-level logger
 * @param topic - logger topic (can be overrided by @LoggerTopic)
 * @returns
 */
declare function InjectMoostLogger(topic?: string): ParameterDecorator & PropertyDecorator;
/**
 * Sets logger topic (used in @InjectMoostLogger)
 * @param topic - logger topic (banner)
 * @returns
 */
declare function LoggerTopic(topic: string): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;

/**
 * ## Pipe
 * ### @Decorator
 * Attach pipe
 * @param handler pipe handler
 * @param priority pipe priority
 * @returns
 */
declare function Pipe(handler: TPipeFn, priority?: TPipePriority): ClassDecorator & MethodDecorator & ParameterDecorator;

/**
 * ## Provide
 * ### @Decorator
 * Defines provide registry for class (and all the children)
 * @param type - string or class constructor
 * @param fn - factory function for provided value
 */
declare function Provide(type: string | TClassConstructor, fn: TProvideFn): ClassDecorator & ParameterDecorator & PropertyDecorator;
/**
 * ## Replace
 * ### @Decorator
 * Defines class to replace in DI
 * @param type - class to replace
 * @param newType - new class
 */
declare function Replace(type: TClassConstructor, newType: TClassConstructor): ClassDecorator;
/**
 * ## Inject
 * ### @Decorator
 * Defines a key from provide registry to inject value
 * (For optional values use with @Optional())
 * @param type - string or class constructor
 */
declare function Inject(type: string | TClassConstructor): ParameterDecorator & PropertyDecorator;
/**
 * Injects instance from scope
 *
 * (scope must be defined by `defineInfactScope` fn)
 * @param name scope name
 */
declare function InjectFromScope(name: string | symbol): ParameterDecorator & PropertyDecorator;
/**
 * Inject vars from scope for instances
 * instantiated with `@InjectFromScope` decorator
 */
declare function InjectScopeVars(name?: string): ParameterDecorator & PropertyDecorator;

/**
 * Hook to the Response Status
 * @decorator
 * @param resolver - resolver function
 * @param label - field label
 * @paramType unknown
 */
declare function Resolve<T extends TObject = TEmpty>(resolver: (metas: TPipeMetas<T>, level: TDecoratorLevel) => unknown, label?: string): ParameterDecorator & PropertyDecorator;
/**
 * Get Param Value from url parh
 * @decorator
 * @param name - param name
 * @paramType string
 */
declare function Param(name: string): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
/**
 * Get Parsed Params from url parh
 * @decorator
 * @paramType object
 */
declare function Params(): ParameterDecorator & PropertyDecorator;
/**
 * Provide Const Value
 * @decorator
 * @param value - provided value
 * @param label - label of the field
 * @paramType unknown
 */
declare function Const<T>(value: T, label?: string): ParameterDecorator & PropertyDecorator;
/**
 * Provide Const Value from Factory fn
 * @decorator
 * @param factory - value Factory fn
 * @param label - label of the field
 * @paramType unknown
 */
declare function ConstFactory<T>(factory: () => T | Promise<T>, label?: string): ParameterDecorator & PropertyDecorator;

declare class InterceptorHandler {
    protected handlers: Array<{
        handler: TInterceptorFn;
        name: string;
    }>;
    constructor(handlers: Array<{
        handler: TInterceptorFn;
        name: string;
    }>);
    protected before: Array<{
        name: string;
        fn: TInterceptorBefore;
    }>;
    protected after: Array<{
        name: string;
        fn: TInterceptorAfter;
    }>;
    protected onError: Array<{
        name: string;
        fn: TInterceptorOnError;
    }>;
    response?: unknown;
    responseOverwritten: boolean;
    get count(): number;
    get countBefore(): number;
    get countAfter(): number;
    get countOnError(): number;
    replyFn(reply: unknown): void;
    init(): Promise<{} | null | undefined>;
    fireBefore(response: unknown): Promise<unknown>;
    fireAfter(response: unknown): Promise<unknown>;
}

interface TMoostEventHandlerHookOptions<T> {
    scopeId: string;
    logger: ReturnType<typeof useEventLogger>;
    unscope: () => void;
    instance?: T;
    method?: keyof T;
    getResponse: () => unknown;
    reply: (r: unknown) => void;
}
interface TMoostEventHandlerOptions<T> {
    contextType?: string | string[];
    loggerTitle: string;
    getIterceptorHandler: () => Promise<InterceptorHandler> | InterceptorHandler | undefined;
    getControllerInstance: () => Promise<T> | T | undefined;
    controllerMethod?: keyof T;
    callControllerMethod?: (args: unknown[]) => unknown;
    resolveArgs?: () => Promise<unknown[]> | unknown[];
    logErrors?: boolean;
    manualUnscope?: boolean;
    hooks?: {
        init?: (opts: TMoostEventHandlerHookOptions<T>) => unknown;
        end?: (opts: TMoostEventHandlerHookOptions<T>) => unknown;
    };
    targetPath: string;
    handlerType: string;
}
declare function registerEventScope(scopeId: string): () => void;
declare function defineMoostEventHandler<T>(options: TMoostEventHandlerOptions<T>): () => Promise<unknown>;

declare function getInstanceOwnMethods<T = TAny>(instance: T): Array<keyof T>;
declare function getInstanceOwnProps<T = TAny>(instance: T): Array<keyof T>;

interface TControllerOverview {
    meta: TMoostMetadata;
    computedPrefix: string;
    type: TFunction;
    handlers: THandlerOverview[];
}
interface THandlerOverview {
    meta: TMoostMetadata;
    path?: string;
    type: string;
    method: string;
    handler: TMoostHandler<TEmpty>;
    registeredAs: Array<{
        path: string;
        args: string[];
    }>;
}
type TContextInjectorHook = 'Event:start' | 'Interceptors:init' | 'Arguments:resolve' | 'Interceptors:before' | 'Handler' | 'Interceptors:after';

interface TMoostOptions {
    /**
     * Prefix that is used for each event path
     */
    globalPrefix?: string;
    logger?: TConsoleBase;
}
/**
 * ## Moost
 * Main moostjs class that serves as a shell for Moost Adapters
 *
 * ### Usage with HTTP Adapter
 * ```ts
 * │  // HTTP server example
 * │  import { MoostHttp, Get } from '@moostjs/event-http'
 * │  import { Moost, Param } from 'moost'
 * │
 * │  class MyServer extends Moost {
 * │      @Get('test/:name')
 * │      test(@Param('name') name: string) {
 * │          return { message: `Hello ${name}!` }
 * │      }
 * │  }
 * │
 * │  const app = new MyServer()
 * │  const http = new MoostHttp()
 * │  app.adapter(http).listen(3000, () => {
 * │      app.getLogger('MyApp').log('Up on port 3000')
 * │  })
 * │  app.init()
 * ```
 * ### Usage with CLI Adapter
 * ```ts
 * │  // CLI example
 * │  import { MoostCli, Cli, CliOption, cliHelpInterceptor } from '@moostjs/event-cli'
 * │  import { Moost, Param } from 'moost'
 * │
 * │  class MyApp extends Moost {
 * │      @Cli('command/:arg')
 * │      command(
 * │         @Param('arg')
 * │         arg: string,
 * │         @CliOption('test', 't')
 * │         test: boolean,
 * │      ) {
 * │          return `command run with flag arg=${ arg }, test=${ test }`
 * │      }
 * │  }
 * │
 * │  const app = new MyApp()
 * │  app.applyGlobalInterceptors(cliHelpInterceptor())
 * │
 * │  const cli = new MoostCli()
 * │  app.adapter(cli)
 * │  app.init()
 * ```
 */
declare class Moost extends Hookable {
    protected options?: TMoostOptions | undefined;
    protected logger: TConsoleBase;
    protected pipes: TPipeData[];
    protected interceptors: TInterceptorData[];
    protected adapters: Array<TMoostAdapter<TAny>>;
    protected controllersOverview: TControllerOverview[];
    protected provide: TProvideRegistry;
    protected replace: TReplaceRegistry;
    protected unregisteredControllers: Array<TObject | TFunction | [string, TObject | TFunction]>;
    constructor(options?: TMoostOptions | undefined);
    _fireEventStart(source: TMoostAdapter<unknown>): void;
    _fireEventEnd(source: TMoostAdapter<unknown>): void;
    /**
     * ### getLogger
     * Provides application logger
     * ```js
     * // get logger with topic = "App"
     * const logger = app.getLogger('App')
     * logger.log('...')
     * ```
     * @param topic
     * @returns
     */
    getLogger(topic?: string): TConsoleBase;
    adapter<T extends TMoostAdapter<TAny>>(a: T): T;
    getControllersOverview(): TControllerOverview[];
    /**
     * ### init
     * Ititializes adapter. Must be called after adapters are attached.
     */
    init(): Promise<void>;
    protected bindControllers(): Promise<void>;
    protected bindController(controller: TFunction | TObject, provide: TProvideRegistry, replace: TReplaceRegistry, globalPrefix: string, replaceOwnPrefix?: string): Promise<void>;
    applyGlobalPipes(...items: Array<TPipeFn | TPipeData>): this;
    protected globalInterceptorHandler?: () => Promise<InterceptorHandler>;
    /**
     * Provides InterceptorHandler with global interceptors and pipes.
     * Used to process interceptors when event handler was not found.
     *
     * @returns IterceptorHandler
     */
    getGlobalInterceptorHandler(): Promise<InterceptorHandler>;
    applyGlobalInterceptors(...items: Array<TInterceptorData['handler'] | TInterceptorData>): this;
    /**
     * Register new entries to provide as dependency injections
     * @param provide - Provide Registry (use createProvideRegistry from '\@prostojs/infact')
     * @returns
     */
    setProvideRegistry(provide: TProvideRegistry): this;
    /**
     * Register replace classes to provide as dependency injections
     * @param replace - Replace Registry (use createReplaceRegistry from '\@prostojs/infact')
     * @returns
     */
    setReplaceRegistry(replace: TReplaceRegistry): this;
    /**
     * Register controllers (similar to @ImportController decorator)
     * @param controllers - list of target controllers (instances)
     * @returns
     */
    registerControllers(...controllers: Array<TObject | TFunction | [string, TObject | TFunction]>): this;
    logMappedHandler(eventName: string, classConstructor: Function, method: string, stroke?: boolean, prefix?: string): void;
}
interface TMoostAdapterOptions<H, T> {
    prefix: string;
    fakeInstance: T;
    getInstance: () => Promise<T>;
    method: keyof T;
    handlers: Array<TMoostHandler<H>>;
    getIterceptorHandler: () => Promise<InterceptorHandler>;
    resolveArgs: () => Promise<unknown[]>;
    logHandler: (eventName: string) => void;
    register: (handler: TMoostHandler<TEmpty>, path: string, args: string[]) => void;
}
interface TMoostAdapter<H> {
    name: string;
    bindHandler: <T extends TObject = TObject>(options: TMoostAdapterOptions<H, T>) => void | Promise<void>;
    onInit?: (moost: Moost) => void | Promise<void>;
    getProvideRegistry?: () => TProvideRegistry;
}

declare function setControllerContext<T>(controller: T, method: keyof T, route: string): void;
declare function useControllerContext<T extends object>(): {
    instantiate: <TT>(c: TClassConstructor<TT>) => Promise<TT>;
    getRoute: () => string | undefined;
    getController: () => T;
    getMethod: () => string | undefined;
    getControllerMeta: <TT extends object>() => (TMoostMetadata<TEmpty> & TT & {
        params: (TT & _prostojs_mate.TMateParamMeta)[];
    }) | undefined;
    getMethodMeta: <TT extends object>(name?: string) => (TMoostMetadata<TEmpty> & TT & {
        params: (TT & _prostojs_mate.TMateParamMeta)[];
    } & {
        params: (TT & _prostojs_mate.TMateParamMeta)[];
    } & _prostojs_mate.TMateClassMeta<(TMoostMetadata<TEmpty> & TT & {
        params: (TT & _prostojs_mate.TMateParamMeta)[];
    })["params"][0]> & _prostojs_mate.TMatePropMeta<(TMoostMetadata<TEmpty> & TT & {
        params: (TT & _prostojs_mate.TMateParamMeta)[];
    })["params"][0]>) | undefined;
    getPropertiesList: () => (string | symbol)[];
    getScope: () => true | TInjectableScope;
    getParamsMeta: () => (_prostojs_mate.TMateParamMeta & TMoostParamsMetadata)[] & (object & _prostojs_mate.TMateParamMeta)[] & (_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & object)[];
    getPropMeta: (name: string) => (TMoostMetadata<TEmpty> & object & {
        params: (object & _prostojs_mate.TMateParamMeta)[];
    } & {
        params: (object & _prostojs_mate.TMateParamMeta)[];
    } & _prostojs_mate.TMateClassMeta<_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & object> & _prostojs_mate.TMatePropMeta<_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & object>) | undefined;
};

/**
 * ### Define Interceptor Function
 *
 * ```ts
 * defineInterceptorFn((before, after, onError) => {
 *         //init
 *         before(() => {
 *              // before handler
 *         })
 *         after((response, reply) => {
 *              // after handler
 *         })
 *         onError((error, reply) => {
 *              // when error occured
 *         })
 *     },
 *     TInterceptorPriority.INTERCEPTOR,
 * )
 * ```
 *
 * @param fn interceptor function
 * @param priority priority of the interceptor where BEFORE_ALL = 0, BEFORE_GUARD = 1, GUARD = 2, AFTER_GUARD = 3, INTERCEPTOR = 4, CATCH_ERROR = 5, AFTER_ALL = 6
 * @returns
 */
declare function defineInterceptorFn(fn: TInterceptorFn, priority?: TInterceptorPriority): TInterceptorFn;
/**
 * Class based interceptor interface
 *
 * Use it to create class-based interceptors and don't forget to make it **@Injectable()**
 *
 * @example
 * "@Injectable()
 * export class MyInterceptor implements TInterceptorClass {
 *     static priority = TInterceptorPriority.INTERCEPTOR
 *     handler: TInterceptorClass['handler'] = (before, after, onError) => {
 *         before((reply) => {
 *             console.log('before')
 *         })
 *         after((response, reply) => {
 *             console.log('after')
 *         })
 *         onError((error, reply) => {
 *             console.log('error')
 *         })
 *     }
 * }
 */
type TInterceptorClass = TClassFunction<TInterceptorFn>;
/**
 * ### Define Pipe Function
 *
 * ```ts
 * // example of a transform pipe
 * const uppercaseTransformPipe = definePipeFn((value, metas, level) => {
 *         return typeof value === 'string' ? value.toUpperCase() : value
 *     },
 *     TPipePriority.TRANSFORM,
 * )
 * ```
 *
 * @param fn interceptor function
 * @param priority priority of the pipe where BEFORE_RESOLVE = 0, RESOLVE = 1, AFTER_RESOLVE = 2, BEFORE_TRANSFORM = 3, TRANSFORM = 4, AFTER_TRANSFORM = 5, BEFORE_VALIDATE = 6, VALIDATE = 7, AFTER_VALIDATE = 8
 * @returns
 */
declare function definePipeFn<T extends TObject = TEmpty>(fn: TPipeFn<T>, priority?: TPipePriority): TPipeFn<T>;

declare function createLogger(opts?: Partial<TProstoLoggerOptions>): ProstoLogger;
declare const loggerConsoleTransport: _prostojs_logger.TProstoLoggerTransportFn<any>;

export { ApplyDecorators, Circular, Const, ConstFactory, Controller, Description, Id, ImportController, Inherit, Inject, InjectEventLogger, InjectFromScope, InjectMoostLogger, InjectScopeVars, Injectable, Intercept, InterceptorHandler, Label, LoggerTopic, Moost, Optional, Param, Params, Pipe, Provide, Replace, Required, Resolve, TInterceptorPriority, TPipePriority, Value, createLogger, defineInfactScope, defineInterceptorFn, defineMoostEventHandler, definePipeFn, getInfactScopeVars, getInstanceOwnMethods, getInstanceOwnProps, getMoostInfact, getMoostMate, getNewMoostInfact, loggerConsoleTransport, registerEventScope, resolvePipe, setControllerContext, setInfactLoggingOptions, useControllerContext };
export type { TCallableClassFunction, TClassConstructor, TClassFunction, TContextInjectorHook, TControllerOverview, TInjectableScope, TInterceptorAfter, TInterceptorBefore, TInterceptorClass, TInterceptorData, TInterceptorFn, TInterceptorOnError, TMoostAdapter, TMoostAdapterOptions, TMoostEventHandlerHookOptions, TMoostEventHandlerOptions, TMoostHandler, TMoostMetadata, TMoostOptions, TMoostParamsMetadata, TPipeData, TPipeFn, TPipeMetas };