moost 0.3.11 → 0.3.13

package/dist/index.d.ts

@@ -1,639 +1,573 @@
-import { createProvideRegistry } from '@prostojs/infact';
-import { EventLogger } from '@wooksjs/event-core';
-import { Infact } from '@prostojs/infact';
-import { Mate } from '@prostojs/mate';
-import { TConsoleBase } from '@prostojs/logger';
-import { THook } from '@wooksjs/event-core';
-import { TMateClassMeta } from '@prostojs/mate';
-import { TMateParamMeta } from '@prostojs/mate';
-import { TMatePropMeta } from '@prostojs/mate';
-import { TProvideFn } from '@prostojs/infact';
-import { TProvideRegistry } from '@prostojs/infact';
-import { useEventContext } from '@wooksjs/event-core';
-import { useEventLogger } from '@wooksjs/event-core';
-
-export declare function Circular<T = unknown>(resolver: () => TClassConstructor<T>): ParameterDecorator;
-
-/**
- * Provide Const Value
- * @decorator
- * @param value - provided value
- * @param label - label of the field
- * @paramType unknown
- */
-export 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
- */
-export declare function ConstFactory<T>(factory: () => T | Promise<T>, label?: string): ParameterDecorator & PropertyDecorator;
-
-/**
- * ## Controller
- * ### @Decorator
- * Set Class as a Controller
- * @param prefix - define the prefix for all the paths of this controller
- */
-export declare function Controller(prefix?: string): ClassDecorator;
-
-export { createProvideRegistry }
-
-/**
- * ### 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
- */
-export declare function defineInterceptorFn(fn: TInterceptorFn, priority?: TInterceptorPriority): TInterceptorFn;
-
-export declare function defineMoostEventHandler<T>(options: TMoostEventHandlerOptions<T>): () => Promise<unknown>;
-
-/**
- * ### 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
- */
-export declare function definePipeFn<T extends TObject = TEmpty>(fn: TPipeFn<T>, priority?: TPipePriority): TPipeFn<T>;
-
-/**
- * ## Description
- * ### @Decorator
- * _Common purpose decorator that may be used by various adapters for various purposes_
- *
- * Stores Description metadata
- */
-export declare function Description(value: string): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-
-export { EventLogger }
-
-export declare function getMoostInfact(): Infact<TMoostMetadata<TEmpty>, TMoostMetadata<TEmpty>, TMoostParamsMetadata, TCustom>;
-
-export declare function getMoostMate<Class extends TObject = TEmpty, Prop extends TObject = TEmpty, Param extends TObject = TEmpty>(): Mate<TMoostMetadata<TEmpty> & Class & {
-    params: (Param & TMateParamMeta)[];
-}, TMoostMetadata<TEmpty> & Prop & {
-    params: (Param & TMateParamMeta)[];
-}>;
-
-export declare function getNewMoostInfact(): Infact<TMoostMetadata<TEmpty>, TMoostMetadata<TEmpty>, TMoostParamsMetadata, TCustom>;
-
-/**
- * ## Id
- * ### @Decorator
- * _Common purpose decorator that may be used by various adapters for various purposes_
- *
- * Stores Id metadata
- */
-export declare function Id(value: string): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-
-/**
- * ## ImportController
- * ### @Decorator
- * Attach sub-controller
- * @param controller - target controller (instance) to import
- * @param provide - provide registry for the target controller
- */
-export 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
- */
-export declare function ImportController(prefix: string, controller: TFunction | TObject, provide?: TProvideRegistry): ClassDecorator;
-
-/**
- * ## Inherit
- * ### @Decorator
- * Inherit metadata from super class
- * @returns
- */
-export declare const Inherit: () => MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-
-/**
- * ## Inject
- * ### @Decorator
- * Defines a key from provide registry to inject value
- * (For optional values use with @Optional())
- * @param type - string or class constructor
- */
-export declare function Inject(type: string | TClassConstructor): ParameterDecorator;
-
-/**
- * ## 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
- */
-export declare function Injectable(scope?: true | TInjectableScope): ClassDecorator;
-
-/**
- * Resolves event logger from event context
- * @param topic
- * @returns Resolver to '@wooksjs/event-core' (EventLogger)
- */
-export declare function InjectEventLogger(topic?: string): ParameterDecorator & PropertyDecorator;
-
-/**
- * ## Intercept
- * ### @Decorator
- * Set interceptor
- * @param handler interceptor fn (use defineInterceptorFn)
- * @param priority interceptor priority
- * @returns
- */
-export declare function Intercept(handler: TCallableClassFunction<TInterceptorFn>, priority?: TInterceptorPriority): ClassDecorator & MethodDecorator;
-
-export declare class InterceptorHandler {
-    protected handlers: TInterceptorFn[];
-    constructor(handlers: TInterceptorFn[]);
-    protected before: TInterceptorBefore[];
-    protected after: TInterceptorAfter[];
-    protected onError: TInterceptorOnError[];
-    response?: unknown;
-    responseOverwritten: boolean;
-    replyFn(reply: unknown): void;
-    init(): Promise<{} | null | undefined>;
-    fireBefore(response: unknown): Promise<unknown>;
-    fireAfter(response: unknown): Promise<unknown>;
-}
-
-/**
- * ## Label
- * ### @Decorator
- * _Common purpose decorator that may be used by various adapters for various purposes_
- *
- * Stores Label metadata
- */
-export declare function Label(value: string): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-
-/**
- * ## 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()
- * ```
- */
-export declare class Moost {
-    protected options?: TMoostOptions | undefined;
-    protected logger: TConsoleBase;
-    protected pipes: TPipeData[];
-    protected interceptors: TInterceptorData[];
-    protected adapters: TMoostAdapter<TAny>[];
-    protected controllersOverview: TControllerOverview[];
-    protected provide: TProvideRegistry;
-    protected unregisteredControllers: (TObject | TFunction | [string, TObject | TFunction])[];
-    constructor(options?: TMoostOptions | undefined);
-    /**
-     * ### 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, globalPrefix: string, replaceOwnPrefix?: string): Promise<void>;
-    applyGlobalPipes(...items: (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: (TInterceptorData['handler'] | TInterceptorData)[]): this;
-    /**
-     * Register new entried to provide as dependency injections
-     * @param provide - Provide Registry (use createProvideRegistry from '\@prostojs/infact')
-     * @returns
-     */
-    setProvideRegistry(provide: TProvideRegistry): this;
-    /**
-     * Register controllers (similar to @ImportController decorator)
-     * @param controllers - list of target controllers (instances)
-     * @returns
-     */
-    registerControllers(...controllers: (TObject | TFunction | [string, TObject | TFunction])[]): this;
-}
-
-/**
- * ## Optional
- * ### @Decorator
- * _Common purpose decorator that may be used by various adapters for various purposes_
- *
- * Stores Optional metadata
- */
-export declare function Optional(): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-
-/**
- * Get Param Value from url parh
- * @decorator
- * @param name - param name
- * @paramType string
- */
-export declare function Param(name: string): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-
-/**
- * Get Parsed Params from url parh
- * @decorator
- * @paramType object
- */
-export declare function Params(): ParameterDecorator & PropertyDecorator;
-
-/**
- * ## Pipe
- * ### @Decorator
- * Attach pipe
- * @param handler pipe handler
- * @param priority pipe priority
- * @returns
- */
-export 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
- */
-export declare function Provide(type: string | TClassConstructor, fn: TProvideFn): ClassDecorator;
-
-export declare function registerEventScope(scopeId: string): () => void;
-
-/**
- * ## Required
- * ### @Decorator
- * _Common purpose decorator that may be used by various adapters for various purposes_
- *
- * Stores Required metadata
- */
-declare function Required_2(): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-export { Required_2 as Required }
-
-/**
- * Hook to the Response Status
- * @decorator
- * @param resolver - resolver function
- * @param label - field label
- * @paramType unknown
- */
-export declare function Resolve<T extends TObject = TEmpty>(resolver: (metas: TPipeMetas<T>, level: TDecoratorLevel) => unknown, label?: string): ParameterDecorator & PropertyDecorator;
-
-export declare const resolvePipe: TPipeFn<TEmpty>;
-
-export declare function setControllerContext<T>(controller: T, method: keyof T): void;
-
-declare type TAny = any;
-
-declare type TAnyFn = {
-    (...a: TAny[]): unknown;
-};
-
-export declare type TCallableClassFunction<T extends TAnyFn = TAnyFn> = T | TClassFunctionConstructor;
-
-declare type TClassConstructor<T = unknown> = new (...args: TAny[]) => T;
-
-export declare interface TClassFunction<T extends TAnyFn = TAnyFn> {
-    handler: T;
-}
-
-declare interface TClassFunctionConstructor<T extends TAnyFn = TAnyFn> {
-    new (...a: TAny[]): TClassFunction<T>;
-}
-
-declare interface TCommonMetaFields {
-    id?: string;
-    label?: string;
-    value?: unknown;
-    description?: string;
-    optional?: boolean;
-    required?: boolean;
-}
-
-declare interface TCommonMoostMeta {
-    inherit?: boolean;
-    pipes?: TPipeData[];
-    resolver?: (metas: TPipeMetas<TAny>, level: TDecoratorLevel) => unknown;
-    type?: TFunction;
-}
-
-export declare interface TControllerOverview {
-    meta: TMoostMetadata;
-    computedPrefix: string;
-    type: TFunction;
-    handlers: THandlerOverview[];
-}
-
-declare interface TCustom {
-    pipes?: TPipeData[];
-}
-
-declare type TDecoratorLevel = 'CLASS' | 'METHOD' | 'PROP' | 'PARAM';
-
-declare interface TEmpty {
-}
-
-declare type TFunction = Function;
-
-declare interface THandlerOverview {
-    meta: TMoostMetadata;
-    path?: string;
-    type: string;
-    method: string;
-    handler: TMoostHandler<TEmpty>;
-    registeredAs: {
-        path: string;
-        args: string[];
-    }[];
-}
-
-export { THook }
-
-export declare type TInjectableScope = 'FOR_EVENT' | 'SINGLETON';
-
-export declare type TInterceptorAfter = (response: TAny, reply: (response: TAny) => void) => void | Promise<void>;
-
-export declare type TInterceptorBefore = (reply: (response: TAny) => void) => void | Promise<void>;
-
-export declare type TInterceptorClass = TClassFunction<TInterceptorFn>;
-
-export declare interface TInterceptorData {
-    handler: TCallableClassFunction<TInterceptorFn>;
-    priority: TInterceptorPriority;
-}
-
-export declare type TInterceptorFn = {
-    (before: (fn: TInterceptorBefore) => void, after: (fn: TInterceptorAfter) => void, onError: (fn: TInterceptorOnError) => void): unknown | Promise<unknown>;
-    priority?: TInterceptorPriority;
-};
-
-export declare type TInterceptorOnError = (error: Error, reply: (response: TAny) => void) => void | Promise<void>;
-
-export declare enum TInterceptorPriority {
-    BEFORE_ALL = 0,
-    BEFORE_GUARD = 1,
-    GUARD = 2,
-    AFTER_GUARD = 3,
-    INTERCEPTOR = 4,
-    CATCH_ERROR = 5,
-    AFTER_ALL = 6
-}
-
-export declare interface TMoostAdapter<H> {
-    bindHandler<T extends TObject = TObject>(options: TMoostAdapterOptions<H, T>): void | Promise<void>;
-    onInit?: (moost: Moost) => void | Promise<void>;
-    getProvideRegistry?: () => TProvideRegistry;
-}
-
-export declare interface TMoostAdapterOptions<H, T> {
-    prefix: string;
-    fakeInstance: T;
-    getInstance: () => Promise<T>;
-    method: keyof T;
-    handlers: TMoostHandler<H>[];
-    getIterceptorHandler: () => Promise<InterceptorHandler>;
-    resolveArgs: () => Promise<unknown[]>;
-    logHandler: (eventName: string) => void;
-    register: (handler: TMoostHandler<TEmpty>, path: string, args: string[]) => void;
-}
-
-export declare interface TMoostEventHandlerHookOptions<T> {
-    restoreCtx: () => void;
-    scopeId: string;
-    logger: ReturnType<typeof useEventLogger>;
-    unscope: () => void;
-    instance?: T;
-    method?: keyof T;
-    getResponse: () => unknown;
-    reply: (r: unknown) => void;
-}
-
-export declare 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;
-    };
-}
-
-export declare type TMoostHandler<T> = {
-    type: string;
-    path?: string;
-} & T;
-
-export declare interface TMoostMetadata<H extends TObject = TEmpty> extends TCommonMetaFields, TCommonMoostMeta {
-    requiredProps?: (string | symbol)[];
-    controller?: {
-        prefix?: string;
-    };
-    importController?: {
-        prefix?: string;
-        typeResolver?: TClassConstructor | (() => TClassConstructor | TObject | Promise<TClassConstructor | TObject>);
-        provide?: TProvideRegistry;
-    }[];
-    properties?: (string | symbol)[];
-    injectable?: true | TInjectableScope;
-    interceptors?: TInterceptorData[];
-    handlers?: TMoostHandler<H>[];
-    returnType?: TFunction;
-    provide?: TProvideRegistry;
-    params: (TMateParamMeta & TMoostParamsMetadata)[];
-}
-
-export declare interface TMoostOptions {
-    /**
-     * Prefix that is used for each event path
-     */
-    globalPrefix?: string;
-    logger?: TConsoleBase;
-}
-
-export declare interface TMoostParamsMetadata extends TCommonMetaFields, TCommonMoostMeta {
-    circular?: () => TAny;
-    inject?: string | symbol | TClassConstructor;
-    nullable?: boolean;
-    paramSource?: string;
-    paramName?: string;
-}
-
-declare type TObject = object;
-
-export declare interface TPipeData {
-    handler: TPipeFn;
-    priority: TPipePriority;
-}
-
-export declare type TPipeFn<T extends TObject = TEmpty> = {
-    (value: unknown, metas: TPipeMetas<T>, level: TDecoratorLevel): unknown | Promise<unknown>;
-    priority?: TPipePriority;
-};
-
-export declare interface TPipeMetas<T extends TObject = TEmpty> {
-    classMeta?: TMoostMetadata & T;
-    methodMeta?: TMoostMetadata & T;
-    propMeta?: TMoostMetadata & T;
-    paramMeta?: TMoostParamsMetadata & T;
-    targetMeta?: TMoostParamsMetadata & T;
-    instance?: TObject;
-    type: TFunction;
-    index?: number;
-    key: string | symbol;
-}
-
-export 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
-}
-
-export { TProvideRegistry }
-
-export declare function useControllerContext<T extends object>(): {
-    instantiate: <T_1>(c: TClassConstructor<T_1>) => Promise<T_1>;
-    getController: () => T;
-    getMethod: () => keyof T;
-    getControllerMeta: () => (TMoostMetadata<TEmpty> & TEmpty & {
-        params: (TEmpty & TMateParamMeta)[];
-    }) | (TMoostMetadata<TEmpty> & TEmpty & {
-        params: (TEmpty & TMateParamMeta)[];
-    } & {
-        params: (TEmpty & TMateParamMeta)[];
-    } & TMateClassMeta<TMateParamMeta & TMoostParamsMetadata & TEmpty> & TMatePropMeta<TMateParamMeta & TMoostParamsMetadata & TEmpty>);
-    getMethodMeta: (name?: string) => TMoostMetadata<TEmpty> & TEmpty & {
-        params: (TEmpty & TMateParamMeta)[];
-    } & {
-        params: (TEmpty & TMateParamMeta)[];
-    } & TMateClassMeta<TMateParamMeta & TMoostParamsMetadata & TEmpty> & TMatePropMeta<TMateParamMeta & TMoostParamsMetadata & TEmpty>;
-    getPropertiesList: () => (string | symbol)[];
-    getScope: () => true | TInjectableScope;
-    getParamsMeta: () => (TMateParamMeta & TMoostParamsMetadata)[] & (TEmpty & TMateParamMeta)[] & (TMateParamMeta & TMoostParamsMetadata & TEmpty)[];
-    getPropMeta: (name: string) => TMoostMetadata<TEmpty> & TEmpty & {
-        params: (TEmpty & TMateParamMeta)[];
-    } & {
-        params: (TEmpty & TMateParamMeta)[];
-    } & TMateClassMeta<TMateParamMeta & TMoostParamsMetadata & TEmpty> & TMatePropMeta<TMateParamMeta & TMoostParamsMetadata & TEmpty>;
-};
-
-export { useEventContext }
-
-export { useEventLogger }
-
-/**
- * ## Value
- * ### @Decorator
- * _Common purpose decorator that may be used by various adapters for various purposes_
- *
- * Stores Value metadata
- */
-export declare function Value(value: unknown): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-
-export { }
+import * as _prostojs_mate from '@prostojs/mate';
+import { TMateParamMeta, Mate } from '@prostojs/mate';
+import { TProvideRegistry, Infact, TProvideFn } from '@prostojs/infact';
+export { TProvideRegistry, createProvideRegistry } from '@prostojs/infact';
+import { TConsoleBase } from '@prostojs/logger';
+import { useEventLogger } from '@wooksjs/event-core';
+export { EventLogger, THook, useEventContext, useEventLogger } from '@wooksjs/event-core';
+
+type TAny = any;
+type TAnyFn = {
+    (...a: TAny[]): unknown;
+};
+type TObject = object;
+type TFunction = Function;
+type TClassConstructor<T = unknown> = new (...args: TAny[]) => T;
+interface TEmpty {
+}
+
+interface TClassFunction<T extends TAnyFn = TAnyFn> {
+    handler: T;
+}
+interface 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>;
+type TInterceptorFn = {
+    (before: (fn: TInterceptorBefore) => void, after: (fn: TInterceptorAfter) => void, onError: (fn: TInterceptorOnError) => void): unknown | Promise<unknown>;
+    priority?: TInterceptorPriority;
+};
+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): ClassDecorator & MethodDecorator;
+
+type TDecoratorLevel = 'CLASS' | 'METHOD' | 'PROP' | 'PARAM';
+
+interface TPipeMetas<T extends TObject = TEmpty> {
+    classMeta?: TMoostMetadata & T;
+    methodMeta?: TMoostMetadata & T;
+    propMeta?: TMoostMetadata & T;
+    paramMeta?: TMoostParamsMetadata & T;
+    targetMeta?: TMoostParamsMetadata & T;
+    instance?: TObject;
+    type: TFunction;
+    index?: number;
+    key: string | symbol;
+}
+type 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?: (string | symbol)[];
+    controller?: {
+        prefix?: string;
+    };
+    importController?: {
+        prefix?: string;
+        typeResolver?: TClassConstructor | (() => TClassConstructor | TObject | Promise<TClassConstructor | TObject>);
+        provide?: TProvideRegistry;
+    }[];
+    properties?: (string | symbol)[];
+    injectable?: true | TInjectableScope;
+    interceptors?: TInterceptorData[];
+    handlers?: TMoostHandler<H>[];
+    returnType?: TFunction;
+    provide?: TProvideRegistry;
+    params: (TMateParamMeta & TMoostParamsMetadata)[];
+}
+interface TMoostParamsMetadata extends TCommonMetaFields, TCommonMoostMeta {
+    circular?: () => TAny;
+    inject?: string | symbol | TClassConstructor;
+    nullable?: boolean;
+    paramSource?: string;
+    paramName?: string;
+}
+type TInjectableScope = 'FOR_EVENT' | 'SINGLETON';
+type TMoostHandler<T> = {
+    type: string;
+    path?: string;
+} & T;
+interface TInterceptorData {
+    handler: TCallableClassFunction<TInterceptorFn>;
+    priority: TInterceptorPriority;
+}
+declare function getMoostMate<Class extends TObject = TEmpty, Prop extends TObject = TEmpty, Param extends TObject = TEmpty>(): Mate<TMoostMetadata<TEmpty> & Class & {
+    params: (Param & TMateParamMeta)[];
+}, TMoostMetadata<TEmpty> & Prop & {
+    params: (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;
+}
+
+declare function getMoostInfact(): Infact<TMoostMetadata<TEmpty>, TMoostMetadata<TEmpty>, TMoostParamsMetadata, TCustom>;
+interface TCustom {
+    pipes?: TPipeData[];
+}
+declare function getNewMoostInfact(): Infact<TMoostMetadata<TEmpty>, TMoostMetadata<TEmpty>, TMoostParamsMetadata, TCustom>;
+
+/**
+ * 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;
+/**
+ * Resolves event logger from event context
+ * @param topic
+ * @returns Resolver to '@wooksjs/event-core' (EventLogger)
+ */
+declare function InjectEventLogger(topic?: string): 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;
+
+/**
+ * ## 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;
+
+declare function Circular<T = unknown>(resolver: () => TClassConstructor<T>): 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;
+/**
+ * ## 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;
+
+/**
+ * ## 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;
+
+/**
+ * ## Inherit
+ * ### @Decorator
+ * Inherit metadata from super class
+ * @returns
+ */
+declare const Inherit: () => 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;
+
+declare class InterceptorHandler {
+    protected handlers: TInterceptorFn[];
+    constructor(handlers: TInterceptorFn[]);
+    protected before: TInterceptorBefore[];
+    protected after: TInterceptorAfter[];
+    protected onError: TInterceptorOnError[];
+    response?: unknown;
+    responseOverwritten: boolean;
+    replyFn(reply: unknown): void;
+    init(): Promise<{} | null | undefined>;
+    fireBefore(response: unknown): Promise<unknown>;
+    fireAfter(response: unknown): Promise<unknown>;
+}
+
+interface TControllerOverview {
+    meta: TMoostMetadata;
+    computedPrefix: string;
+    type: TFunction;
+    handlers: THandlerOverview[];
+}
+interface THandlerOverview {
+    meta: TMoostMetadata;
+    path?: string;
+    type: string;
+    method: string;
+    handler: TMoostHandler<TEmpty>;
+    registeredAs: {
+        path: string;
+        args: string[];
+    }[];
+}
+
+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 {
+    protected options?: TMoostOptions | undefined;
+    protected logger: TConsoleBase;
+    protected pipes: TPipeData[];
+    protected interceptors: TInterceptorData[];
+    protected adapters: TMoostAdapter<TAny>[];
+    protected controllersOverview: TControllerOverview[];
+    protected provide: TProvideRegistry;
+    protected unregisteredControllers: (TObject | TFunction | [string, TObject | TFunction])[];
+    constructor(options?: TMoostOptions | undefined);
+    /**
+     * ### 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, globalPrefix: string, replaceOwnPrefix?: string): Promise<void>;
+    applyGlobalPipes(...items: (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: (TInterceptorData['handler'] | TInterceptorData)[]): this;
+    /**
+     * Register new entried to provide as dependency injections
+     * @param provide - Provide Registry (use createProvideRegistry from '\@prostojs/infact')
+     * @returns
+     */
+    setProvideRegistry(provide: TProvideRegistry): this;
+    /**
+     * Register controllers (similar to @ImportController decorator)
+     * @param controllers - list of target controllers (instances)
+     * @returns
+     */
+    registerControllers(...controllers: (TObject | TFunction | [string, TObject | TFunction])[]): this;
+}
+interface TMoostAdapterOptions<H, T> {
+    prefix: string;
+    fakeInstance: T;
+    getInstance: () => Promise<T>;
+    method: keyof T;
+    handlers: TMoostHandler<H>[];
+    getIterceptorHandler: () => Promise<InterceptorHandler>;
+    resolveArgs: () => Promise<unknown[]>;
+    logHandler: (eventName: string) => void;
+    register: (handler: TMoostHandler<TEmpty>, path: string, args: string[]) => void;
+}
+interface TMoostAdapter<H> {
+    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): void;
+declare function useControllerContext<T extends object>(): {
+    instantiate: <T_1>(c: TClassConstructor<T_1>) => Promise<T_1>;
+    getController: () => T;
+    getMethod: () => keyof T;
+    getControllerMeta: () => (TMoostMetadata<TEmpty> & TEmpty & {
+        params: (TEmpty & _prostojs_mate.TMateParamMeta)[];
+    }) | (TMoostMetadata<TEmpty> & TEmpty & {
+        params: (TEmpty & _prostojs_mate.TMateParamMeta)[];
+    } & {
+        params: (TEmpty & _prostojs_mate.TMateParamMeta)[];
+    } & _prostojs_mate.TMateClassMeta<_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & TEmpty> & _prostojs_mate.TMatePropMeta<_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & TEmpty>);
+    getMethodMeta: (name?: string) => TMoostMetadata<TEmpty> & TEmpty & {
+        params: (TEmpty & _prostojs_mate.TMateParamMeta)[];
+    } & {
+        params: (TEmpty & _prostojs_mate.TMateParamMeta)[];
+    } & _prostojs_mate.TMateClassMeta<_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & TEmpty> & _prostojs_mate.TMatePropMeta<_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & TEmpty>;
+    getPropertiesList: () => (string | symbol)[];
+    getScope: () => true | TInjectableScope;
+    getParamsMeta: () => (_prostojs_mate.TMateParamMeta & TMoostParamsMetadata)[] & (TEmpty & _prostojs_mate.TMateParamMeta)[] & (_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & TEmpty)[];
+    getPropMeta: (name: string) => TMoostMetadata<TEmpty> & TEmpty & {
+        params: (TEmpty & _prostojs_mate.TMateParamMeta)[];
+    } & {
+        params: (TEmpty & _prostojs_mate.TMateParamMeta)[];
+    } & _prostojs_mate.TMateClassMeta<_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & TEmpty> & _prostojs_mate.TMatePropMeta<_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & TEmpty>;
+};
+
+interface TMoostEventHandlerHookOptions<T> {
+    restoreCtx: () => void;
+    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;
+    };
+}
+declare function registerEventScope(scopeId: string): () => void;
+declare function defineMoostEventHandler<T>(options: TMoostEventHandlerOptions<T>): () => Promise<unknown>;
+
+/**
+ * ### 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;
+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>;
+
+export { Circular, Const, ConstFactory, Controller, Description, Id, ImportController, Inherit, Inject, InjectEventLogger, Injectable, Intercept, InterceptorHandler, Label, Moost, Optional, Param, Params, Pipe, Provide, Required, Resolve, type TCallableClassFunction, type TClassFunction, type TControllerOverview, type TInjectableScope, type TInterceptorAfter, type TInterceptorBefore, type TInterceptorClass, type TInterceptorData, type TInterceptorFn, type TInterceptorOnError, TInterceptorPriority, type TMoostAdapter, type TMoostAdapterOptions, type TMoostEventHandlerHookOptions, type TMoostEventHandlerOptions, type TMoostHandler, type TMoostMetadata, type TMoostOptions, type TMoostParamsMetadata, type TPipeData, type TPipeFn, type TPipeMetas, TPipePriority, Value, defineInterceptorFn, defineMoostEventHandler, definePipeFn, getMoostInfact, getMoostMate, getNewMoostInfact, registerEventScope, resolvePipe, setControllerContext, useControllerContext };