import { DIContainer } from "../../common";
import { IO, Middleware, MiddlewareFunction, MiddlewareRegistry } from "../common";
import { Route } from "./route";
import { RouteGroup } from "./route.group";
import { RouteRegistry } from "./route.registry";
import type { ApiDocFragment } from "./api-doc";
import type { HttpContract } from "./contracts";
export declare enum MiddlewareType {
    Security = "security",
    Session = "session",
    Compression = "compression",
    Cors = "cors",
    RateLimit = "rate_limit",
    Validation = "validation",
    AuthenticatedOnly = "authenticated_only",
    AuthorizedOnly = "authenticated_only",
    NonAuthenticatedOnly = "non_authenticated_only",
    SelfOnly = "self_only"
}
export type RouteConfig = {
    path: string;
    method: "PUT" | "POST" | "GET" | "DELETE" | "PATCH" | "CONNECT" | "HEAD" | "OPTIONS" | "TRACE" | "ALL";
} & RouteAdditionalOptions;
export type RouteAdditionalOptions = {
    cors?: RouteCorsOptions;
    security?: RouteSecurityOptions;
    rateLimit?: RouteRateLimitOptions;
    validation?: RouteValidationOptions;
    session?: {
        store?: "memory" | "file" | "db";
        duration?: number;
        [key: string]: any;
    };
    cache?: {
        ttl: number;
        store?: "memory" | "db" | "file";
        [key: string]: any;
    };
    logging?: {
        level?: "info" | "debug" | "warn" | "error";
        excludeHeaders?: string[];
        [key: string]: any;
    };
    analytics?: {
        provider?: string;
        excludeRoutes?: string[];
        [key: string]: any;
    };
    audit?: {
        store?: "db" | "file";
        redactFields?: string[];
        [key: string]: any;
    };
    roles?: {
        authenticatedOnly?: boolean;
        allow?: string[];
        deny?: string[];
        selfOnly?: boolean | AnyHandler;
        [key: string]: any;
    };
    middlewares?: {
        pre?: MiddlewareFunction[];
        post?: MiddlewareFunction[];
        [key: string]: any;
    };
    compression?: RouteCompressionOptions;
    apiDoc?: ApiDocFragment;
    contract?: HttpContract | HttpContract[];
    [key: string]: unknown;
};
export type RoutesConfig = {
    login?: RouteConfig;
    logout?: RouteConfig;
    refresh?: RouteConfig;
    [key: string]: RouteConfig | undefined;
};
export type RouteCompressionOptions = {
    chunkSize?: number;
    filter?: AnyFilter;
    level?: number;
    memLevel?: number;
    strategy?: number;
    threshold?: number;
    windowBits?: number;
    [key: string]: any;
};
export type RouteCorsOptions = {
    origin?: string | string[] | RegExp | boolean;
    methods?: string | string[];
    headers?: string | string[];
    credentials?: boolean;
    exposedHeaders?: string | string[];
    maxAge?: number;
    [key: string]: any;
};
export type RouteSecurityOptions = {
    contentSecurityPolicy?: any;
    crossOriginEmbedderPolicy?: any;
    crossOriginOpenerPolicy?: any;
    crossOriginResourcePolicy?: any;
    originAgentCluster?: any;
    referrerPolicy?: any;
    [key: string]: any;
};
export type RouteRateLimitOptions = {
    maxRequests?: number;
    windowMs?: number;
    [key: string]: any;
};
export type ValidationOptions = {
    validator?: string;
    schema?: any;
    [key: string]: any;
};
export type RouteValidationOptions = {
    request?: ValidationOptions;
    response?: ValidationOptions;
};
export type AnyHandler<T = any> = (...args: any[]) => T;
export type AnyFilter = AnyHandler;
export type HandlerResult<T = unknown> = {
    content?: T;
    error?: Error;
};
export type RequestMethod = "PUT" | "POST" | "GET" | "DELETE" | "PATCH" | "CONNECT" | "HEAD" | "OPTIONS" | "TRACE" | "ALL";
export interface AuthUser {
    id: string | number;
    email?: string;
    username?: string;
    roles?: string[];
    permissions?: string[];
    [key: string]: any;
}
export interface AuthState<TUser extends AuthUser = AuthUser> {
    token?: string;
    type?: string;
    payload?: any;
    result?: AuthResult<TUser>;
    tokens?: AuthResult<TUser>["tokens"];
    session?: AuthResult<TUser>["session"];
    [key: string]: any;
}
export interface AuthRequest<TUser extends AuthUser = AuthUser> {
    user?: TUser;
    auth?: AuthState<TUser>;
    session?: any;
    sessionID?: string;
    [key: string]: any;
}
export declare enum AuthType {
    JWT = "jwt",
    LOCAL = "local",
    GOOGLE = "google",
    GITHUB = "github",
    FACEBOOK = "facebook",
    API_KEY = "api_key",
    SESSION = "session",
    BASIC = "basic"
}
export interface AuthResult<TUser extends AuthUser = AuthUser> {
    user: TUser;
    tokens?: {
        accessToken?: string;
        refreshToken?: string;
        [key: string]: string | undefined;
    };
    session?: {
        sessionId: string;
        data?: any;
    };
}
export interface AuthStrategy<TUser extends AuthUser = AuthUser, TContext extends HttpContext = HttpContext> {
    readonly name: string;
    init?(): Promise<void>;
    authenticate(ctx: TContext): Promise<AuthResult<TUser> | null>;
    logout?(ctx: TContext): Promise<void>;
    refresh?(ctx: TContext): Promise<AuthResult<TUser>>;
}
export interface AuthConfig<TUser extends AuthUser = AuthUser, TContext extends HttpContext = HttpContext> {
    strategies: AuthStrategy<TUser, TContext>[];
    session?: SessionConfig;
    defaultStrategy?: string;
}
export interface RoleConfig {
    authenticatedOnly?: boolean;
    allow?: string[];
    deny?: string[];
    selfOnly?: boolean | ((user: AuthUser, resourceId: string) => boolean);
    customCheck?: (user: AuthUser, req: AuthRequest) => boolean | Promise<boolean>;
}
export interface SessionConfig {
    secret: string;
    name?: string;
    store?: 'memory' | 'db' | 'file';
    cookie?: {
        secure?: boolean;
        httpOnly?: boolean;
        maxAge?: number;
        sameSite?: 'strict' | 'lax' | 'none';
        domain?: string;
        path?: string;
    };
    resave?: boolean;
    saveUninitialized?: boolean;
    rolling?: boolean;
    unset?: 'destroy' | 'keep';
    redis?: {
        url?: string;
        host?: string;
        port?: number;
        password?: string;
        db?: number;
        prefix?: string;
    };
    mongodb?: {
        url?: string;
        collection?: string;
        touchAfter?: number;
        ttl?: number;
    };
    file?: {
        path?: string;
        ttl?: number;
        reapInterval?: number;
    };
    genid?: () => string;
    proxy?: boolean;
    touchAfter?: number;
}
export interface HttpRequest {
    method: string;
    path: string;
    headers: Record<string, string | string[] | undefined>;
    body?: any;
    query?: Record<string, any>;
    params?: Record<string, any>;
    files?: any;
    cookies?: Record<string, string>;
    secure?: boolean;
    ip?: string;
    memoryInfo?: any;
    connection?: {
        remoteAddress?: string;
    };
    [key: string]: any;
}
export interface HttpResponse {
    status(code: number): HttpResponse;
    json(data: any): HttpResponse;
    cookie(name: string, value: string, options?: any): HttpResponse;
    setHeader(name: string, value: string): HttpResponse;
    locals?: Record<string, any>;
    [key: string]: any;
}
export interface HttpContext {
    req: HttpRequest;
    res: HttpResponse;
    next: () => void;
}
export interface RouteMetadata {
    method: RequestMethod;
    path: string;
    middlewares: MiddlewareMetadata[];
    useCase?: any;
    routeIO?: IO;
    handler?: AnyHandler;
    options?: RouteAdditionalOptions;
}
export interface MiddlewareMetadata {
    type: string;
    options: any;
    order: number;
    middleware?: any;
}
export interface ControllerMetadata {
    basePath: string;
    middlewares: MiddlewareMetadata[];
    type?: 'http' | 'websocket';
    options?: {
        apiDoc?: ApiDocFragment;
    };
}
export interface PluginLifecycle {
    install<Framework>(app: HttpApp<Framework>, options?: any): Promise<void>;
    uninstall?<Framework>(app: HttpApp<Framework>): void;
    beforeStart?<Framework>(app: HttpApp<Framework>): void;
    afterStart?<Framework>(app: HttpApp<Framework>): void;
    beforeStop?<Framework>(app: HttpApp<Framework>): void;
    afterStop?<Framework>(app: HttpApp<Framework>): void;
    gracefulShutdown?<Framework>(app: HttpApp<Framework>, signals?: string[]): Promise<void>;
}
export interface PluginMetadata {
    name: string;
    version?: string;
    description?: string;
    author?: string;
    dependencies?: string[];
    peerDependencies?: string[];
    tags?: string[];
    category?: string;
}
export interface HttpPlugin extends PluginLifecycle, PluginMetadata {
    middleware?: MiddlewareMetadata[];
    routes?: RouteMetadata[];
    config?: Record<string, any>;
    installed?: boolean;
    enabled?: boolean;
    install<Framework>(app: HttpApp<Framework>, options?: any): Promise<void>;
}
export interface PluginRegistry {
    register(plugin: HttpPlugin): void;
    unregister(pluginName: string): void;
    get(pluginName: string): HttpPlugin | undefined;
    list(): HttpPlugin[];
    install<Framework>(app: HttpApp<Framework>, pluginName: string, options?: any): Promise<void>;
    isInstalled(pluginName: string): boolean;
    getInstalled(): HttpPlugin[];
}
export interface PluginManager {
    usePlugin(plugin: HttpPlugin, options?: any): void;
    listPlugins(): HttpPlugin[];
    getPlugin(pluginName: string): HttpPlugin | undefined;
    isPluginLoaded(pluginName: string): boolean;
}
export interface HttpApp<Framework = any> {
    start(port: number): Promise<void>;
    stop(): Promise<void>;
    gracefulShutdown(signals?: string[]): Promise<void>;
    getApp(): Framework;
    getServer<T>(): T;
    getRouteRegistry(): RouteRegistry;
    getMiddlewareRegistry(): MiddlewareRegistry;
    getContainer(): DIContainer;
    register(...item: (Route | RouteGroup)[]): this;
    useMiddleware(...middlewares: Middleware[]): this;
    usePlugin(plugin: HttpPlugin, options?: any): this;
    getPlugin(pluginName: string): HttpPlugin | undefined;
    listPlugins(): HttpPlugin[];
    isDevelopment(): boolean;
    isProduction(): boolean;
    isTest(): boolean;
    isStaging(): boolean;
}