API @deepkit/http Documentation // package // Deepkit Enterprise TypeScript Framework

export class HttpActionDecorator {
    t;
    onDecorator(target: ClassType, property: string | undefined, parameterIndexOrDescriptor?: any);
    name(name: string);
    description(description: string);
    serialization(options: SerializationOptions);
    serializer(serializer: Serializer);
    middleware(...middlewares: HttpActionMiddleware[]);
    /**
     * Allows to change the HttpAction object and composite multiple properties into one function.
     *
     * @example
     * ```typescript
     * const authGroup = Symbol('authGroup');
     *
     * function authGroup(group: 'admin' | 'user') {
     *    return (action: HttpAction) => {
     *        action.data.set(authGroup, group);
     *    };
     * }
     *
     * class My Controller {
     *    @http.GET('/assets').use(authGroup('admin'))
     *    assets() {}
     * }
     * ```
     */
    use(use: (action: HttpAction) => void);
    /**
     * Arbitrary value container that can be read in RouterParameterResolver and all
     * HTTP workflow events (like authentication).
     *
     * @example
     * ```typescript
     * class My Controller {
     *    @http.GET('/assets').data('authGroup', 'admin')
     *    assets() {}
     * }
     * ```
     */
    data(name: string, value: any);
    category(category: string);
    group(...group: string[]);
    GET(path: string = );
    HEAD(path: string = );
    POST(path: string = );
    PUT(path: string = );
    DELETE(path: string = );
    OPTIONS(path: string = );
    TRACE(path: string = );
    PATCH(path: string = );
    ANY(path: string = );
    /**
     * Adds additional information about what HTTP status codes are available in this route.
     * You can add additionally a description and a response body type.
     *
     * The type is used for serialization for responses with the given statusCode.
     *
     * This information is available in Deepkit API console.
     *
     * ```typescript
     *
     * http.GET().response<boolean>(200, 'All ok')
     *
     * interface User {
     *     username: string;
     * }
     * http.GET().response<User>(200, 'User object')
     *
     * interface HttpErrorMessage {
     *     error: string;
     * }
     * http.GET().response<HttpErrorMessage>(500, 'Error')
     * ```
     */
    response<T>(statusCode: number, description: string = , type?: ReceiveType<T>);
    /**
     * Adds a parameter resolver for parameters based on the class type. Use .resolveParameterByName() for name-based resolving.
     *
     * ```typescript
     *
     * class UserResolver {
     *     resolve(context: RouteParameterResolverContext): any | Promise<any> {
     *         return new User();
     *     }
     * }
     *
     * class MyController {
     *     @http.GET()
     *     @http.resolveParameter(User, UserResolver)
     *     myAction(user: User) {
     *     }
     * }
     *
     * new App({providers: [UserResolver]}).run();
     * ```
     */
    resolveParameter(classType: ClassType | string | any, resolver: ClassType<RouteParameterResolver>);
    /**
     * Adds a parameter resolver for parameters based on its name. Use .resolveParameter() for class-based resolving.
     *
     * ```typescript
     *
     * class UserResolver {
     *     resolve(context: RouteParameterResolverContext): any | Promise<any> {
     *         return new User();
     *     }
     * }
     *
     * class MyController {
     *     @http.GET()
     *     @http.resolveParameterByName('user', UserResolver)
     *     myAction(user: User) {
     *     }
     * }
     *
     * new App({providers: [UserResolver]}).run();
     * ```
     */
    resolveParameterByName(name: string, resolver: ClassType<RouteParameterResolver>);
}
API `@deepkit/http`

Classes

Errors

Const

Functions

Types
