import { z } from 'zod';
import type { RouteMethod, SchemaDefinition, RouteSettings, RouteRatelimits } from './core-types';
declare class RouteManager {
    items: Map<string, any>;
    server: any;
    init(): void;
    mergeSchemas(schemas: Map<string, any>): void;
    resolveUrl(url: string): {
        route: any;
        params: Record<string, string>;
        path: string;
    } | null;
}
declare class SchemaManager {
    items: Map<string, any>;
    server: any;
    init(): void;
}
declare class ConnectionManager {
    init(): Promise<boolean>;
}
declare class RatelimitManager {
    items: Map<string, any>;
    check(api: any): boolean;
    increase(api: any): void;
    cleanup(): void;
}
declare class Server<TAuth = any, TServices = any> {
    routes: RouteManager;
    schemas: SchemaManager;
    connections: ConnectionManager;
    ratelimits: RatelimitManager;
    config: {
        port: number;
        hostname: string;
        responseDetailLevel: 'full' | 'mid' | 'low' | 'blank';
        defaults: any;
        ratelimits: any;
    };
    services: TServices;
    authenticationMethod: (token: string) => Promise<TAuth> | TAuth;
    routesBasePath: string;
    init(): Promise<void>;
    start(): Promise<void>;
}
declare class API<TBody = unknown, TParams = unknown, TQuery = unknown, TResponse = unknown, TAuth = any, TServices = any> {
    method: RouteMethod;
    body: TBody;
    params: TParams;
    query: TQuery;
    headers: any;
    ip: string;
    rawPath: string;
    authentication: TAuth;
    services: TServices;
    server: Server<TAuth, TServices>;
    header(key: string, value: string): void;
    status(code: number): void;
    throw(status: number, options?: {
        data?: any;
    }): never;
    send(data?: any, options?: {
        error?: boolean;
        status?: number;
        code?: string;
        message?: string;
    }): never;
    sendTyped(data: TResponse, options?: {
        error?: boolean;
        status?: number;
        code?: string;
        message?: string;
    }): never;
}
export interface APIBase {
    method: RouteMethod;
    body: unknown;
    params: unknown;
    query: unknown;
    headers: any;
    ip: string;
    rawPath: string;
    header(key: string, value: string): void;
    status(code: number): void;
    throw(status: number, options?: {
        data?: any;
    }): never;
}
export type APISendMethod = {
    send(data?: any, options?: {
        error?: boolean;
        status?: number;
        code?: string;
        message?: string;
    }): never;
};
export type APISendTypedMethod<TResponse> = {
    sendTyped(data: TResponse, options?: {
        error?: boolean;
        status?: number;
        code?: string;
        message?: string;
    }): never;
};
type ExtractParams<V> = V extends {
    params: infer T;
} ? T extends z.ZodTypeAny ? z.infer<T> : unknown : unknown;
type ExtractBody<V, M extends RouteMethod> = M extends 'GET' ? unknown : V extends {
    [K in M]: {
        body: infer T;
    };
} ? T extends z.ZodTypeAny ? z.infer<T> : unknown : unknown;
type ExtractQuery<V, M extends RouteMethod> = V extends {
    [K in M]: {
        query: infer T;
    };
} ? T extends z.ZodTypeAny ? z.infer<T> : unknown : unknown;
type ExtractResponse<V, M extends RouteMethod> = V extends {
    [K in M]: {
        response: infer T;
    };
} ? T extends z.ZodTypeAny ? z.infer<T> : unknown : unknown;
export type GetSchemaType<V, M extends RouteMethod, K extends 'body' | 'params' | 'query' | 'response'> = V extends object ? K extends 'params' ? ExtractParams<V> : K extends 'body' ? ExtractBody<V, M> : K extends 'query' ? ExtractQuery<V, M> : K extends 'response' ? ExtractResponse<V, M> : unknown : unknown;
type HasResponseSchema<V, M extends RouteMethod> = V extends {
    [K in M]: {
        response: z.ZodTypeAny;
    };
} ? true : false;
export type BaseAPI<TBody = unknown, TParams = unknown, TQuery = unknown, TResponse = unknown, TAuth = any, TServices = any> = APIBase & {
    authentication: TAuth;
    services: TServices;
};
export type APIWithSend<TBody = unknown, TParams = unknown, TQuery = unknown, TResponse = unknown, TAuth = any, TServices = any> = BaseAPI<TBody, TParams, TQuery, TResponse, TAuth, TServices> & APISendMethod;
export type APIWithSendTyped<TBody = unknown, TParams = unknown, TQuery = unknown, TResponse = unknown, TAuth = any, TServices = any> = BaseAPI<TBody, TParams, TQuery, TResponse, TAuth, TServices> & APISendMethod & APISendTypedMethod<TResponse>;
export type APIDeprecatedSend<TBody = unknown, TParams = unknown, TQuery = unknown, TResponse = unknown, TAuth = any, TServices = any> = Omit<API<TBody, TParams, TQuery, TResponse, TAuth, TServices>, 'send'> & {
    /**
     * @deprecated Use sendTyped instead for type-safe responses when a response schema is defined
     */
    send(data?: any, options?: {
        error?: boolean;
        status?: number;
        code?: string;
        message?: string;
    }): never;
    sendTyped(data: TResponse, options?: {
        error?: boolean;
        status?: number;
        code?: string;
        message?: string;
    }): never;
};
export type ConditionalAPI<V, M extends RouteMethod, TAuth = any, TServices = any> = HasResponseSchema<V, M> extends true ? APIDeprecatedSend<GetSchemaType<V, M, 'body'>, GetSchemaType<V, M, 'params'>, GetSchemaType<V, M, 'query'>, GetSchemaType<V, M, 'response'>, TAuth, TServices> : Omit<API<GetSchemaType<V, M, 'body'>, GetSchemaType<V, M, 'params'>, GetSchemaType<V, M, 'query'>, GetSchemaType<V, M, 'response'>, TAuth, TServices>, 'sendTyped'>;
export type RouteDefinition<V extends SchemaDefinition = object, TAuth = any, TServices = any> = Partial<{
    [M in RouteMethod]: (api: ConditionalAPI<V, M, TAuth, TServices>) => void;
}> & {
    schema?: V;
    settings?: Partial<RouteSettings<TAuth, TServices>> & {
        [M in RouteMethod]?: Partial<RouteSettings<TAuth, TServices>>;
    };
    ratelimits?: Partial<RouteRatelimits> & {
        [M in RouteMethod]?: Partial<RouteRatelimits>;
    };
};
export type { RouteMethod, SchemaDefinition, Config, Request, Response, RouteRatelimits, RouteSettings, } from './core-types';