import { Request as Request$1, Response as Response$1, NextFunction, Router } from 'express';
export { NextFunction, Router } from 'express';
import { Logger } from 'pino';
import { HttpLogger as HttpLogger$1 } from 'pino-http';
import { ClassConstructor, Transform as Transform$1, ClassTransformOptions } from 'class-transformer';
import { Socket as Socket$1, Server, Namespace } from 'socket.io';
import { BaseEntity as BaseEntity$1, Repository, ObjectType } from 'typeorm';
import { ValidationError, ValidatorOptions } from 'class-validator';
export * from 'class-validator';

declare class BaseClass {
}

declare type HttpHandleMethod = 'checkout' | 'copy' | 'delete' | 'get' | 'head' | 'lock' | 'merge' | 'mkactivity' | 'mkcol' | 'move' | 'm-search' | 'notify' | 'options' | 'patch' | 'patch' | 'post' | 'purge' | 'put' | 'report' | 'search' | 'subscribe' | 'trace' | 'unlock' | 'unsubscribe';

declare type HttpControllerMethodHander = <IRequest extends Request$1, IResponse extends Response$1, INext extends NextFunction>(request: IRequest, response: IResponse, next: INext) => Promise<unknown>;
declare type HttpHandlerSubject = {
    method: HttpHandleMethod;
    path: string;
    handler: HttpControllerMethodHander;
    propertyName: string;
};
declare type ControllerMiddlewareSubject = Pick<HttpHandlerSubject, 'handler'> & Partial<Pick<HttpHandlerSubject, 'path' | 'method'>>;
declare const META_DATA: {
    /**
     * @description Metadata has type HttpHandlerSubject[]
     */
    HttpHandler: string;
    /**
     * @description Metadata has type HttpControllerMethodHander
     */
    PropertyMiddleware: string;
    /**
     * @description Metadata has type ControllerMiddlewareSubject
     */
    ControllerMiddleware: string;
    /**
     * @description Metadata has type string
     */
    DefaultPath: string;
};
declare class HttpController extends BaseClass {
    constructor(router: Router);
}

declare const Route: (method: HttpHandleMethod, path?: string) => (target: any, name: string, descriptor: PropertyDescriptor) => void;
declare const Controller: (path: string) => (target: object) => void;
declare const Middleware: (handler: HttpControllerMethodHander) => (target: any, name: string, descriptor: PropertyDescriptor) => void;

declare type Request = Request$1;

declare type Response = Response$1 & ResponseUtils;
declare type ResponseUtils = {
    resSuccess(data?: unknown): ResponseUtils;
    resError(message: string, otherPayload?: Record<string, unknown>, options?: {
        statusCode?: number;
    }): ResponseUtils;
};
declare const ResponseUtils: (response: Response$1) => ResponseUtils;

declare type DefaultLogger = Logger;
declare const defaultLogger: () => DefaultLogger;

declare type HttpLogger = HttpLogger$1;
declare const httpLogger: () => HttpLogger;

declare class Mapper<I> {
    _t: I;
    static toClass<Cl>(this: ClassConstructor<Cl>, plain: Cl extends Mapper<infer I> ? I : never): Cl;
}

declare const Transform: typeof Transform$1;

declare type Socket = Socket$1;

declare class SocketClass extends BaseClass {
    io: Server | Namespace;
    constructor(socketServerOrNamespace: Server | Namespace);
}

declare function SocketEvent(event: string): (target: object, _: string, descriptor: PropertyDescriptor) => void;

declare abstract class BaseEntity extends BaseEntity$1 {
    id: string;
    createdAt: Date;
    updatedAt: Date;
}

declare class BaseRepositoryClass<T> extends Repository<T> {
    findById(id: string): Promise<T | undefined>;
}
interface BaseRepository<Entity> {
    findById: (id: string | number) => Promise<Entity | undefined>;
}
declare type BaseRepositoryWithThis<Entity> = BaseRepository<Entity> & ThisType<Repository<Entity> & BaseRepository<Entity>>;
declare const createBaseRepository: <Entity extends BaseEntity$1>() => BaseRepository<Entity>;

/**
 * @deprecated
 */
declare const getLazyCustomRepository: <R extends object>(repository: ObjectType<R>, connectionName?: string) => R;

interface ValidateClassType<T> {
    new (...args: any[]): T;
}
declare type ValidBodyRequest<ValidateClass, IRequest extends Request$1 = Request$1> = IRequest extends Request$1<infer P, infer BRes, infer _BReq, infer Q> ? Request$1<P, BRes, ValidateClass, Q> : never;

declare type ValidateErrorProps<T = unknown> = {
    validateClass: ValidateClassType<T>;
    payload: any;
    validateErrors: ValidationError[];
    logFirstError?: boolean;
};
declare class ValidateError<T = unknown> {
    validateClass: ValidateClassType<T>;
    payload: any;
    validateErrors: ValidationError[];
    logFirstError: boolean;
    constructor(props: ValidateErrorProps<T>);
    get firstErrorMessage(): string;
    toJson(): Record<string, string[]>;
}

declare const HttpBodyValidate: <T extends object>(validateClass: ValidateClassType<T>, options?: {
    validator?: ValidatorOptions | undefined;
    transformer?: ClassTransformOptions | undefined;
} | undefined) => ReturnType<typeof Middleware>;

export { BaseClass, BaseEntity, BaseRepositoryClass, BaseRepositoryWithThis, Controller, ControllerMiddlewareSubject, DefaultLogger, HttpBodyValidate, HttpController, HttpControllerMethodHander, HttpHandleMethod, HttpHandlerSubject, HttpLogger, META_DATA, Mapper, Middleware, Request, Response, ResponseUtils, Route, Socket, SocketClass, SocketEvent, Transform, ValidBodyRequest, ValidateClassType, ValidateError, ValidateErrorProps, createBaseRepository, defaultLogger, getLazyCustomRepository, httpLogger };