import { Provider } from '@neoskop/injector'; import { Request, Response } from 'express'; import { HttpError } from '../errors/http'; import { Observable } from 'rxjs'; export declare abstract class AbstractController { providers?: Provider[]; } export interface IControllerOptions { providers?: Provider[]; } /** * Type of Controller decorator */ export interface ControllerDecorator { /** * Defines a class as controller * @example * ``` * * @Controller() * export class TestController() {} * ``` */ (options?: IControllerOptions): any; new (options?: IControllerOptions): Controller; } /** * Type of Controller metadata * @see {@link ControllerDecorator} */ export interface Controller extends AbstractController { } export declare const Controller: ControllerDecorator; /** * Type of Controller decorator */ export interface JsonControllerDecorator { /** * Defines a class as json controller * @example * ``` * * * @JsonController() * export class JsonController() {} * ``` */ (options?: IControllerOptions): any; new (options?: IControllerOptions): JsonController; } /** * Type of JsonController metadata * @see {@link JsonControllerDecorator} */ export interface JsonController extends AbstractController { } export declare const JsonController: JsonControllerDecorator; export declare abstract class AbstractMethod { abstract method: 'all' | 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head'; abstract path: RegExp | string; } /** * Type of Method decorator */ export interface MethodDecorator { (path: RegExp | string): any; new (path: RegExp | String): T; } /** * Type of All metadata * @see {@link MethodDecorator} * @example * ``` * * @Controller() * export class TestController { * @All('/') * index() {} * } * ``` */ export interface All extends AbstractMethod { } export declare const All: MethodDecorator; /** * Type of Get metadata * @see {@link MethodDecorator} * @example * ``` * * @Controller() * export class TestController { * @Get('/') * index() {} * } * ``` */ export interface Get extends AbstractMethod { } export declare const Get: MethodDecorator; /** * Type of Post metadata * @see {@link MethodDecorator} * @example * ``` * * @Controller() * export class TestController { * @Post('/') * index() {} * } * ``` */ export interface Post extends AbstractMethod { } export declare const Post: MethodDecorator; /** * Type of Put metadata * @see {@link MethodDecorator} * @example * ``` * * @Controller() * export class TestController { * @Put('/') * index() {} * } * ``` */ export interface Put extends AbstractMethod { } export declare const Put: MethodDecorator; /** * Type of Delete metadata * @see {@link MethodDecorator} * @example * ``` * * @Controller() * export class TestController { * @Delete('/') * index() {} * } * ``` */ export interface Delete extends AbstractMethod { } export declare const Delete: MethodDecorator; /** * Type of Patch metadata * @see {@link MethodDecorator} * @example * ``` * * @Controller() * export class TestController { * @Patch('/') * index() {} * } * ``` */ export interface Patch extends AbstractMethod { } export declare const Patch: MethodDecorator; /** * Type of Options metadata * @see {@link MethodDecorator} * @example * ``` * * @Controller() * export class TestController { * @Options('/') * index() {} * } * ``` */ export interface Options extends AbstractMethod { } export declare const Options: MethodDecorator; /** * Type of Head metadata * @see {@link MethodDecorator} * @example * ``` * * @Controller() * export class TestController { * @Head('/') * index() {} * } * ``` */ export interface Head extends AbstractMethod { } export declare const Head: MethodDecorator; export declare abstract class ApplicableAnnotation { abstract before?(options: this, { request, response }: { request: Request; response: Response; }): void | Promise; abstract after?(options: this, { request, response, result }: { request: Request; response: Response; result: any; }): void | Promise; abstract end?(options: this, { request, response, result }: { request: Request; response: Response; result: any; }): void | Promise; } /** * Type of ContentType decorator */ export interface ContentTypeDecorator { (contentType: string): any; new (contentType: string): ContentType; } /** * Type of ContentType metadata */ export interface ContentType extends ApplicableAnnotation { contentType: string; } export declare const ContentType: ContentTypeDecorator; /** * Type of StatusCode decorator */ export interface StatusCodeDecorator { /** * Defines a status code * @example * ``` * @Controller() * export class TestController { * @Get('/') * @StatusCode(202) * index() {} * * @Get('/test') * test() { * return Result([ new StatusCode(201) ]); * } * } * ``` */ (status: number): any; new (status: number): StatusCode; } /** * Type of StatusCode metadata */ export interface StatusCode extends ApplicableAnnotation { status: number; } export declare const StatusCode: StatusCodeDecorator; export interface IRedirectOptions { status?: number; } /** * Type of Redirect decorator */ export interface RedirectDecorator { /** * Defines a redirect * @example * ``` * @Controller() * export class TestController { * @Get('/') * @Redirect('https://example.com') * index() {} * * @Get('/test') * test() { * return Result([ new Redirect('https://example.com') ]); * } * } * ``` */ (url: string, options?: IRedirectOptions): any; new (url: string, options?: IRedirectOptions): Redirect; } /** * Type of Redirect metadata */ export interface Redirect extends ApplicableAnnotation, IRedirectOptions { url: string; status: number; } export declare const Redirect: RedirectDecorator; /** * Type of Header decorator */ export interface HeaderDecorator { /** * Defines a header * @example * ``` * @Controller() * export class TestController { * @Get('/') * @Header('ETag', 'foobar') * index() {} * * @Get('/test') * test() { * return Result([ new Header('ETag', 'foobar') ]); * } * } * ``` */ (name: string, value: string): any; new (name: string, value: string): Header; } /** * Type of Header metadata */ export interface Header extends ApplicableAnnotation { headerName: string; value: string; } export declare const Header: HeaderDecorator; /** * Type of View decorator */ export interface ViewDecorator { /** * Defines the view to render * @example * ``` * @Controller() * export class TestController { * @Get('/') * @View('index') * index() {} * * @Get('/test') * test() { * return Result([ new View('test) ]); * } * } * ``` */ (view: string): any; new (view: string): View; } /** * Type of View metadata */ export interface View extends ApplicableAnnotation { view: string; } export declare const View: ViewDecorator; /** * Type of Locals decorator */ export interface LocalsDecorator { /** * Defines local view variables * @example * ``` * @Controller() * export class TestController { * @Get('/') * @Locals({ foo: 'bar' }) * index() {} * * @Get('/test') * test() { * return Result([ new Locals({ foo: 'bar' }) ]); * } * } * ``` */ (locals: Object): any; new (locals: Object): Locals; } /** * Type of Locals metadata */ export interface Locals extends ApplicableAnnotation { locals: Object; } export declare const Locals: LocalsDecorator; /** * Type of Json decorator */ export interface JsonDecorator { /** * Defines controller handler to return json * @example * ``` * @Controller() * export class TestController { * @Get('/') * @Json() * index() { * return null; * } * * @Get('/test') * test() { * return Result([ new Json() ], null); * } * } * ``` */ (): any; new (): Json; } /** * Type of Json metadata */ export interface Json extends ApplicableAnnotation { } export declare const Json: JsonDecorator; /** * Type of Raw decorator */ export interface RawDecorator { /** * Defines controller handler to return raw data * @example * ``` * @Controller() * export class TestController { * @Get('/') * @Raw() * index() { * return 'string'; * } * * @Get('/test') * test() { * return Result([ new Raw() ], new Buffer('buffer')); * } * } * ``` */ (): any; new (): Raw; } /** * Type of Raw metadata */ export interface Raw extends ApplicableAnnotation { } export declare const Raw: RawDecorator; /** * Type of Text decorator */ export interface TextDecorator { /** * Defines controller handler to return text * @example * ``` * @Controller() * export class TestController { * @Get('/') * @Text() * index() { * return null; * } * * @Get('/test') * test() { * return Result([ new Text() ], null); // throw an error * } * } * ``` */ (): any; new (): Text; } /** * Type of Text metadata */ export interface Text extends ApplicableAnnotation { } export declare const Text: TextDecorator; /** * Type of Noop decorator */ export interface NoopDecorator { /** * Defines controller handler to do nothing * @example * ``` * @Controller() * export class TestController { * @Post('/login') * @Use(passport.authenticate({ successRedirect: '/', failureRedirect: '/login' }) * @Noop() * doLogin() {} * } * ``` */ (): any; new (): Noop; } /** * Type of Noop metadata */ export interface Noop extends ApplicableAnnotation { } export declare const Noop: NoopDecorator; export declare type SSEWrite = (data: { event?: string; data?: string | object; retry?: number; id?: string | number; }) => void; export declare type SSEErrorHandler = (sse: SSE, options: { write: SSEWrite; request: Request; response: Response; result: Observable; }) => void | Promise; export interface ISSEOptions { errorHandler?: string | SSEErrorHandler; retryOnError?: number; } /** * Type of SSE decorator */ export interface SSEDecorator { /** * Defines controller handler to return server-send events. Method *MUST* return an observable * @example * ``` * @Controller() * export class TestController { * @Get('/events') * @SSE() * doLogin() { * return interval(1000).pipe(take(10)) * } * } * ``` */ (options?: ISSEOptions): any; new (options?: ISSEOptions): SSE; } /** * Type of SSE metadata */ export interface SSE extends ApplicableAnnotation { errorHandler: string | SSEErrorHandler; retryOnError?: number; } export declare const SSE: SSEDecorator; /** * Type of OnUndefined decorator */ export interface OnUndefinedDecorator { /** * Defines what to do on `undefined` return value * @example * ``` * @Controller() * export class TestController { * @Get('/') * @OnUndefined(404) * index() { * } * * @Get('/test') * test() { * return Result([ new OnUndefined(new NotFoundError()) ]); * } * } * ``` */ (statusOrError: number | HttpError): any; new (statusOrError: number | HttpError): OnUndefined; } /** * Type of OnUndefined metadata */ export interface OnUndefined extends ApplicableAnnotation { statusOrError: number | HttpError; } export declare const OnUndefined: OnUndefinedDecorator; /** * Type of OnNull decorator */ export interface OnNullDecorator { /** * Defines what to do on `null` return value * @example * ``` * @Controller() * export class TestController { * @Get('/') * @OnUndefined(404) * index() { * return null * } * * @Get('/test') * test() { * return Result([ new OnUndefined(new NotFoundError()) ], null); * } * } * ``` */ (statusOrError: number | HttpError): any; new (statusOrError: number | HttpError): OnNull; } /** * Type of OnNull metadata */ export interface OnNull extends ApplicableAnnotation { statusOrError: number | HttpError; } export declare const OnNull: OnNullDecorator;