lacis/dist/index.d.ts

Zero-dependency TypeScript web framework

import { S as ServerConfig, A as AdapterRequest, a as AdapterResponse, R as Request, b as Response, c as ServerlessRoute, M as MiddlewareType, d as MiddlewareCallback, P as PathMiddlewares, N as NotFoundHook, e as ShutdownHook, f as ServerlessMiddleware, C as CorsConfig, g as SSEOptions, h as SSEClientOptions, i as SSEEventHandlers, j as SSEClient } from './index-pGWdfH82.js';
export { k as Adapter, l as AdapterContext, m as ClusterConfig, n as CookieOptions, H as Handler, o as MiddlewareModule, p as RequestCookies, q as ResponseCookies, r as Route, s as RouteHandlers, t as SSEContext, u as ServerlessConfig, U as UploadedFile } from './index-pGWdfH82.js';
import { Server, ServerResponse, IncomingMessage } from 'http';

interface VercelRequest {
    url?: string;
    method?: string;
    headers: Record<string, string | string[] | undefined>;
    cookies: Record<string, string>;
    body?: any;
    query?: Record<string, string | string[]>;
}
interface VercelResponse {
    statusCode?: number;
    headersSent: boolean;
    status: (statusCode: number) => VercelResponse;
    json: (body: any) => VercelResponse;
    send: (body: any) => VercelResponse;
    redirect: (statusOrUrl: string | number, url?: string) => VercelResponse;
    setHeader: (name: string, value: string | string[]) => VercelResponse;
    getHeader: (name: string) => string | string[] | undefined;
    end: (data?: any) => void;
}
interface NetlifyEvent {
    rawUrl: string;
    rawQuery: string;
    path: string;
    httpMethod: string;
    headers: Record<string, string | undefined>;
    multiValueHeaders: Record<string, string[] | undefined>;
    queryStringParameters: Record<string, string | undefined> | null;
    multiValueQueryStringParameters: Record<string, string[] | undefined> | null;
    body: string | null;
    isBase64Encoded: boolean;
    route?: string;
}
interface NetlifyContext {
    callbackWaitsForEmptyEventLoop: boolean;
    functionName: string;
    functionVersion: string;
    invokedFunctionArn: string;
    memoryLimitInMB: string;
    awsRequestId: string;
    logGroupName: string;
    logStreamName: string;
    identity?: Record<string, any>;
    clientContext?: Record<string, any>;
    getRemainingTimeInMillis(): number;
}
interface NetlifyResponse {
    statusCode: number;
    headers?: Record<string, boolean | number | string>;
    multiValueHeaders?: Record<string, readonly (boolean | number | string)[]>;
    body?: string;
    isBase64Encoded?: boolean;
}
type NetlifyHandler = (event: NetlifyEvent, context: NetlifyContext) => Promise<NetlifyResponse>;
type PlatformHandler = ((config?: ServerConfig) => Server) | ((req: AdapterRequest, res: AdapterResponse) => Promise<void>) | ((event: NetlifyEvent, context: NetlifyContext) => Promise<NetlifyResponse>);

interface MetricValue {
    min: number;
    max: number;
    avg: number;
    count: number;
    sum: number;
    p50?: number;
    p90?: number;
    p99?: number;
}
interface Metrics {
    timestamp: number;
    uptime: number;
    requestCount: number;
    activeRequests: number;
    errorCount: number;
    responseTimes: MetricValue;
    statusCodes: Record<number, number>;
    memory: {
        rss: number;
        heapTotal: number;
        heapUsed: number;
        external: number;
        arrayBuffers: number;
    };
    cpu: {
        usage: number;
        system: number;
        user: number;
    };
    systemLoad: number[];
    systemMemory: {
        total: number;
        free: number;
        used: number;
    };
}
interface PerformanceData {
    startTime: number;
    requestCount: number;
    activeRequests: number;
    errorCount: number;
    responseTimes: number[];
    statusCodes: Record<number, number>;
    responseTimesBucket: number[];
    lastReport: number;
    lastReset: number;
}
interface MonitorOptions {
    sampleInterval?: number;
    reportInterval?: number;
    resetInterval?: number;
    enableHistogram?: boolean;
    logToConsole?: boolean;
    thresholds?: {
        cpu?: number;
        memory?: number;
        responseTime?: number;
        errorRate?: number;
    };
}
interface AlarmStatus {
    cpu: boolean;
    memory: boolean;
    responseTime: boolean;
    errorRate: boolean;
}

interface WorkerStats {
    pid: number;
    load: number;
    lastUsed: number;
    memoryUsage: NodeJS.MemoryUsage;
}
interface BalancerOptions {
    reportInterval?: number;
}
interface StatsMessage {
    type: "stats";
    stats: Partial<WorkerStats>;
}

declare const defaultConfig: ServerConfig;
declare function getConfig(customConfig?: Partial<ServerConfig>): ServerConfig;

interface StandardSchema<Input = unknown, Output = Input> {
    readonly "~standard": {
        readonly version: 1;
        readonly vendor: string;
        readonly validate: (value: unknown) => StandardResult<Output> | Promise<StandardResult<Output>>;
        readonly types?: {
            readonly input: Input;
            readonly output: Output;
        };
    };
}
type StandardResult<Output> = {
    readonly value: Output;
    readonly issues?: undefined;
} | {
    readonly issues: ReadonlyArray<StandardIssue>;
};
interface StandardIssue {
    readonly message: string;
    readonly path?: ReadonlyArray<PropertyKey | {
        readonly key: PropertyKey;
    }>;
}
type InferOutput<T extends StandardSchema> = NonNullable<T["~standard"]["types"]>["output"];
type ValidatedRequest<TParams extends StandardSchema | undefined, TQuery extends StandardSchema | undefined, TBody extends StandardSchema | undefined> = Omit<Request, "params" | "query" | "body"> & {
    params: TParams extends StandardSchema ? InferOutput<TParams> : Record<string, string> | undefined;
    query: TQuery extends StandardSchema ? InferOutput<TQuery> : Record<string, string> | undefined;
    body: TBody extends StandardSchema ? InferOutput<TBody> : () => Promise<Buffer>;
};
interface HandlerMeta {
    summary?: string;
    description?: string;
    tags?: string[];
    deprecated?: boolean;
}
interface HandlerCacheOptions {
    ttl: number;
    maxSize?: number;
    key?: (req: Request) => string;
}
interface DefineHandlerConfig<TParams extends StandardSchema | undefined = undefined, TQuery extends StandardSchema | undefined = undefined, TBody extends StandardSchema | undefined = undefined> {
    params?: TParams;
    query?: TQuery;
    body?: TBody;
    meta?: HandlerMeta;
    cache?: HandlerCacheOptions;
    handler: (req: ValidatedRequest<TParams, TQuery, TBody>, res: Response) => void | Promise<void>;
}
type DefinedHandler = ((req: Request, res: Response) => Promise<void>) & {
    _defineHandler: DefineHandlerConfig<any, any, any>;
};
declare function defineHandler<TParams extends StandardSchema | undefined = undefined, TQuery extends StandardSchema | undefined = undefined, TBody extends StandardSchema | undefined = undefined>(config: DefineHandlerConfig<TParams, TQuery, TBody>): DefinedHandler;

interface OpenApiInfo {
    title: string;
    version: string;
    description?: string;
}
interface OpenApiConfig {
    path?: string;
    info: OpenApiInfo;
}
declare function buildOpenApiDoc(config: OpenApiConfig): Promise<Record<string, any>>;

declare function createServer(routesDir: string, config?: ServerConfig): Promise<unknown>;

interface RouteMatchResult {
    handler: Function | null;
    params: Record<string, string>;
    allowedMethods?: string[];
}
interface RouteError {
    error: string;
    status?: number;
    allowedMethods?: string[];
}
type FindRouteResult = {
    handler: Function;
    params: Record<string, string>;
} | RouteError | null;
declare class Router {
    private rootNode;
    private cachedRoutes;
    private routeCount;
    private lastLoaded;
    private verbose;
    constructor();
    private createNode;
    addRoute(method: string, routePath: string, handler: Function): Router;
    findRoute(method: string, url: string): RouteMatchResult;
    private traverse;
    loadRoutes(routesDir: string): Promise<boolean>;
    getRoutes(): Array<{
        method: string;
        path: string;
        handler: Function;
    }>;
    private collectRoutes;
    getStats(): {
        routeCount: number;
        lastLoaded: number;
        uptime: number;
        cacheSize: number;
    };
    setVerbose(verbose: boolean): Router;
    reset(): void;
}
declare const router: Router;
declare function isRouteError(obj: any): obj is RouteError;
declare function registerRoutes(routes: ServerlessRoute[]): void;
declare function loadRoutes(routesDir: string): Promise<boolean | undefined>;
declare function findRoute(url: string, method?: string): FindRouteResult;
declare function getRoutesDir(customDir?: string): string;
declare function getRouterStats(): {
    routeCount: number;
    lastLoaded: number;
    uptime: number;
    cacheSize: number;
};
declare function setVerboseLogging(verbose: boolean): void;
declare function resetRouter(): void;

declare function addMiddleware(middlewareName: MiddlewareType, callback: MiddlewareCallback): {
    remove: () => void;
};
declare function addPathMiddleware(p: string, type: MiddlewareType, callback: MiddlewareCallback): {
    remove: () => void;
};
declare function addExactPathMiddleware(p: string, type: MiddlewareType, callback: MiddlewareCallback): {
    remove: () => void;
};
declare function collectMiddleware(url: string): {
    beforeRequest: MiddlewareCallback[];
    afterRequest: MiddlewareCallback[];
    onError: MiddlewareCallback[];
};
declare function hasMiddlewares(): boolean;
declare function runMiddlewares(middlewareName: MiddlewareType, req: Request, res: Response, context?: any): Promise<boolean>;
declare function loadMiddlewares(routesDir: string): Promise<void>;
declare function getPathMiddlewares(): PathMiddlewares;
declare function registerMiddlewares(middlewares?: ServerlessMiddleware[]): void;
declare function registerHooksConfig(config?: {
    onNotFound?: NotFoundHook;
    onShutdown?: ShutdownHook;
}): void;
declare function hasNotFoundHook(): boolean;
declare function runNotFoundHook(req: Request, res: Response): Promise<void>;
declare function runShutdownHook(): Promise<void>;
declare function resetMiddlewares(): void;
declare function registerMiddlewareConfig(config?: {
    beforeRequest?: MiddlewareCallback | MiddlewareCallback[];
    afterRequest?: MiddlewareCallback | MiddlewareCallback[];
    onError?: MiddlewareCallback | MiddlewareCallback[];
}): void;

declare const HTTP_STATUS: {
    OK: number;
    CREATED: number;
    NO_CONTENT: number;
    BAD_REQUEST: number;
    UNAUTHORIZED: number;
    FORBIDDEN: number;
    NOT_FOUND: number;
    METHOD_NOT_ALLOWED: number;
    CONFLICT: number;
    UNPROCESSABLE_ENTITY: number;
    TOO_MANY_REQUESTS: number;
    INTERNAL_SERVER_ERROR: number;
    SERVICE_UNAVAILABLE: number;
    GATEWAY_TIMEOUT: number;
};
interface HttpError {
    name: string;
    code: number;
    message: string;
    details?: any;
    expose: boolean;
    log: boolean;
    stack?: string;
}
declare function createHttpError(options: {
    name?: string;
    code?: number;
    message?: string;
    details?: any;
    expose?: boolean;
    log?: boolean;
}): HttpError;
declare function sendError(error: HttpError, res: ServerResponse): void;
declare function logError(error: HttpError): void;
declare function createBadRequestError(message?: string, details?: any): HttpError;
declare function createUnauthorizedError(message?: string, details?: any): HttpError;
declare function createForbiddenError(message?: string, details?: any): HttpError;
declare function createNotFoundError(message?: string, details?: any): HttpError;
declare function createMethodNotAllowedError(message?: string, details?: any): HttpError;
declare function createConflictError(message?: string, details?: any): HttpError;
declare function createValidationError(message?: string, details?: any): HttpError;
declare function createRateLimitError(message?: string, details?: any): HttpError;
declare function createInternalServerError(message?: string, details?: any): HttpError;
declare function createServiceUnavailableError(message?: string, details?: any): HttpError;
declare function createGatewayTimeoutError(message?: string, details?: any): HttpError;
declare function normalizeError(error: any): HttpError;
declare function isHttpError(error: any): error is HttpError;

interface RateLimitOptions {
    windowMs?: number;
    max?: number;
    message?: string;
    keyGenerator?: (req: Request) => string;
}
declare function createRateLimit(options?: RateLimitOptions): MiddlewareCallback;

interface CacheEntry {
    body: any;
    status: number;
    contentType: string;
    expiresAt: number;
}
declare function createStore(maxSize: number): {
    get: (key: string) => CacheEntry | undefined;
    set: (key: string, entry: CacheEntry) => void;
};
type Store = ReturnType<typeof createStore>;
declare function interceptResponse(res: Response, onCapture: (entry: Omit<CacheEntry, "expiresAt">) => void): void;
declare function replayEntry(res: Response, entry: CacheEntry): void;
declare function defaultCacheKey(req: Request): string;
interface ResponseCacheOptions {
    ttl: number;
    methods?: string[];
    maxSize?: number;
    keyGenerator?: (req: Request) => string;
    match?: (req: Request) => boolean;
    exclude?: string | string[];
    shouldCache?: (req: Request, res: Response) => boolean;
}
declare function createResponseCache(options: ResponseCacheOptions): MiddlewareCallback;
interface WithCacheOptions {
    ttl: number;
    maxSize?: number;
    key?: (req: Request) => string;
}
declare function withCache(options: WithCacheOptions, handler: (req: Request, res: Response) => void | Promise<void>): (req: Request, res: Response) => Promise<void>;

declare function createCorsMiddleware(config: CorsConfig): MiddlewareCallback;
declare function registerCorsConfig(cors?: CorsConfig): void;

interface ResLike {
    readonly writableEnded: boolean;
    write(chunk: any): any;
    end(data?: any): any;
    writeHead(code: number, headers?: Record<string, string>): any;
    on(event: string, cb: () => void): any;
}
declare class SSEContext {
    private _res;
    private _timeoutId;
    constructor(_res: ResLike, timeout: number);
    send(data: string): boolean;
    json(data: any): boolean;
    event(event: string, data: any): boolean;
    comment(text: string): boolean;
    id(id: string): boolean;
    retry(ms: number): boolean;
    close(comment?: string): void;
    error(event: string, message: string, code?: number, details?: string): void;
}
declare function initSSE(res: ServerResponse, options?: SSEOptions): SSEContext;

/**
 * Creates a Server-Sent Events (SSE) client that can handle both URL connections and existing SSE streams
 * @param urlOrReq - URL to connect to or an existing IncomingMessage
 * @param options - Configuration options for the SSE client
 * @param handlers - Event handlers for the SSE connection
 * @param req - Optional IncomingMessage to inherit headers from
 * @returns A Promise resolving to an SSE client for URL connections, or an SSE client directly for existing connections
 */
declare function createSSEClient(urlOrReq: string | IncomingMessage, options?: SSEClientOptions, handlers?: SSEEventHandlers, req?: IncomingMessage): Promise<SSEClient> | SSEClient;

export { AdapterRequest, AdapterResponse, type AlarmStatus, type BalancerOptions, type CacheEntry, CorsConfig, type DefineHandlerConfig, type DefinedHandler, HTTP_STATUS, type HandlerCacheOptions, type HandlerMeta, type InferOutput, type MetricValue, type Metrics, MiddlewareCallback, MiddlewareType, type MonitorOptions, type NetlifyContext, type NetlifyEvent, type NetlifyHandler, type NetlifyResponse, NotFoundHook, type OpenApiConfig, type OpenApiInfo, PathMiddlewares, type PerformanceData, type PlatformHandler, type RateLimitOptions, Request, Response, type ResponseCacheOptions, SSEClient, SSEClientOptions, SSEEventHandlers, SSEOptions, ServerConfig, ServerlessMiddleware, ServerlessRoute, ShutdownHook, type StandardIssue, type StandardSchema, type StatsMessage, type Store, type ValidatedRequest, type VercelRequest, type VercelResponse, type WithCacheOptions, type WorkerStats, addExactPathMiddleware, addMiddleware, addPathMiddleware, buildOpenApiDoc, collectMiddleware, createBadRequestError, createConflictError, createCorsMiddleware, createForbiddenError, createGatewayTimeoutError, createHttpError, createInternalServerError, createMethodNotAllowedError, createNotFoundError, createRateLimit, createRateLimitError, createResponseCache, createSSEClient, createServer, createServiceUnavailableError, createStore, createUnauthorizedError, createValidationError, defaultCacheKey, defaultConfig, defineHandler, findRoute, getConfig, getPathMiddlewares, getRouterStats, getRoutesDir, hasMiddlewares, hasNotFoundHook, initSSE, interceptResponse, isHttpError, isRouteError, loadMiddlewares, loadRoutes, logError, normalizeError, registerCorsConfig, registerHooksConfig, registerMiddlewareConfig, registerMiddlewares, registerRoutes, replayEntry, resetMiddlewares, resetRouter, router, runMiddlewares, runNotFoundHook, runShutdownHook, sendError, setVerboseLogging, withCache };