balda-js 0.0.2 → 0.0.4

package/lib/index.d.cts

@@ -1,1492 +0,0 @@
-import { TSchema } from '@sinclair/typebox/type';
-import { TSchema as TSchema$1, Type, Static } from '@sinclair/typebox';
-import { IncomingMessage, Server as Server$1 } from 'node:http';
-import { pino } from 'pino';
-import nodeCron, { TaskContext } from 'node-cron';
-
-/**
- * Type of Swagger UI to use
- */
-type SwaggerUIType = "standard" | "redoc" | "rapidoc";
-/**
- * Type of request body for a route
- */
-type SwaggerBodyType = "json" | "form-data" | "urlencoded";
-/**
- * JSONSchema type for OpenAPI/AJV-compatible schemas
- */
-type JSONSchema = {
-    $id?: string;
-    $schema?: string;
-    type?: string | string[];
-    properties?: Record<string, JSONSchema>;
-    items?: JSONSchema | JSONSchema[];
-    required?: string[];
-    enum?: any[];
-    allOf?: JSONSchema[];
-    oneOf?: JSONSchema[];
-    anyOf?: JSONSchema[];
-    not?: JSONSchema;
-    additionalProperties?: boolean | JSONSchema;
-    description?: string;
-    format?: string;
-    default?: any;
-    title?: string;
-    definitions?: Record<string, JSONSchema>;
-    [key: string]: any;
-};
-/**
- * Global documentation options for the API (OpenAPI/Swagger style)
- */
-type SwaggerGlobalOptions = {
-    /** The path to the swagger documentation, defaults to /docs for the UI and /docs/json for the raw json */
-    path?: string;
-    /** Type of Swagger UI to use, one of 'standard', 'redoc', or 'rapidoc'. Defaults to 'standard'. */
-    type?: SwaggerUIType;
-    /** API title */
-    title?: string;
-    /** API description */
-    description?: string;
-    /** API version */
-    version?: string;
-    /** Server URLs */
-    servers?: string[];
-    /** Components (schemas, responses, parameters, etc.) */
-    components?: Record<string, any>;
-    /** Security schemes (OpenAPI 3.0 style) */
-    securitySchemes?: Record<string, Security>;
-    /** OpenID Connect configuration (discovery document) */
-    openIdConnect?: OpenIDConnectConfig;
-    /** API tags */
-    tags?: Record<string, any>;
-    /** Global security requirements */
-    security?: Security[];
-    /** External documentation */
-    externalDocs?: {
-        description?: string;
-        url: string;
-    };
-    /** Info object (detailed metadata) */
-    info?: {
-        title: string;
-        description?: string;
-        version: string;
-        termsOfService?: string;
-        contact?: {
-            name?: string;
-            url?: string;
-            email?: string;
-        };
-        license?: {
-            name: string;
-            url?: string;
-        };
-    };
-    /**
-     * OpenAPI models to be shown in the documentation. Must be valid OpenAPI/AJV JSONSchema objects.
-     */
-    models?: Record<string, JSONSchema>;
-};
-/**
- * Route-specific documentation options (for individual endpoints)
- */
-type SwaggerRouteOptions = {
-    /** Service category where the route belongs to */
-    service?: string;
-    /** Name of the route */
-    name?: string;
-    /** Query parameters schema */
-    query?: TSchema;
-    /** Request body schema */
-    requestBody?: TSchema;
-    /** Responses for this route */
-    responses?: Record<number, TSchema>;
-    /** Errors for this route */
-    errors?: Record<number, TSchema>;
-    /** Security requirements for this route */
-    security?: Security[] | Security;
-    /** Description of the route */
-    description?: string;
-    /** Deprecated flag */
-    deprecated?: boolean;
-    /** Exclude from swagger */
-    excludeFromSwagger?: boolean;
-    /**
-     * The request body type for this route. Allowed values: 'json', 'form-data', 'urlencoded'. Defaults to 'json'.
-     */
-    bodyType?: SwaggerBodyType;
-};
-type OAuth2Flows = {
-    implicit?: OAuth2Flow;
-    authorizationCode?: OAuth2Flow;
-    clientCredentials?: OAuth2Flow;
-    password?: OAuth2Flow;
-};
-type OAuth2Flow = {
-    authorizationUrl?: string;
-    tokenUrl?: string;
-    refreshUrl?: string;
-    scopes: Record<string, string>;
-};
-type OpenIDConnectConfig = {
-    issuer: string;
-    authorizationEndpoint: string;
-    tokenEndpoint: string;
-    userinfoEndpoint?: string;
-    jwksUri: string;
-    endSessionEndpoint?: string;
-    introspectionEndpoint?: string;
-    revocationEndpoint?: string;
-    scopesSupported?: string[];
-    responseTypesSupported?: string[];
-    grantTypesSupported?: string[];
-    tokenEndpointAuthMethodsSupported?: string[];
-    subjectTypesSupported?: string[];
-    idTokenSigningAlgValuesSupported?: string[];
-    claimsSupported?: string[];
-    codeChallengeMethodsSupported?: string[];
-};
-type Security = BearerOptions | ApiKeyOptions | OAuth2Options | OpenIdConnectOptions;
-type BearerOptions = {
-    type: "bearer";
-    bearerFormat?: string;
-    description?: string;
-};
-type ApiKeyOptions = {
-    type: "apiKey";
-    name: string;
-    in: "header" | "query" | "cookie";
-    description?: string;
-};
-type OAuth2Options = {
-    type: "oauth2";
-    flows: OAuth2Flows;
-    description?: string;
-    name?: string;
-};
-type OpenIdConnectOptions = {
-    type: "openIdConnect";
-    openIdConnectUrl: string;
-    description?: string;
-    name?: string;
-};
-
-/**
- * Decorator to mark a class as a controller, routes defined in the controller will be registered at import time when calling the `listen` method.
- * You can customize the path pattern for controller imports in the server options `controllerPatterns`
- * @param path - The path pattern for the controller.
- * @param swaggerOptions - The swagger options for the controller that will be applied to all routes defined in the controller. Controller options will override route options.
- * @swagger If swagger is enabled, the default service name for all routes defined in the controller will be the controller name.
- * @swagger For naming commodity, the default service name will remove the "Controller" suffix if it exists. e.g. "UserController" -> "User"
- */
-declare const controller: (path?: string, swaggerOptions?: SwaggerRouteOptions) => (target: any) => void;
-
-type FormFile = {
-    /**
-     * The name of the form field.
-     */
-    formName: string;
-    /**
-     * The mime type of the file. (e.g. "image/png")
-     */
-    mimeType: string;
-    /**
-     * The size of the file in bytes.
-     */
-    size: number;
-    /**
-     * The temporary path of the file. Will be deleted after the request is processed automatically even in error cases.
-     */
-    tmpPath: string;
-    /**
-     * The original filename (including extension) as sent by the client
-     * (e.g. "avatar.png", "document.txt").
-     */
-    originalName: string;
-};
-type FilePluginOptions = {
-    /**
-     * The maximum size of the file in bytes.
-     */
-    maxFileSize?: number;
-};
-
-declare global {
-    interface Request {
-        params: Record<string, string>;
-        query: Record<string, string>;
-    }
-}
-declare class NativeRequest extends Request {
-}
-
-/**
- * The request object.
- * This is the main object that is passed to the handler function.
- * It contains the request body, query parameters, files, cookies, etc.
- * It also contains the validation methods.
- */
-declare class Request$1 extends NativeRequest {
-    static fromRequest(request: Request$1 | NativeRequest): Request$1;
-    /**
-     * Enrich native request with validation methods.
-     */
-    static enrichRequest(request: Request$1): Request$1;
-    /**
-     * The file of the request. Only available for multipart/form-data requests and if the file parser middleware is used.
-     */
-    file: (fieldName: string) => FormFile | null;
-    /**
-     * The cookies of the request. Only available if the cookie middleware is used.
-     */
-    cookies: Record<string, string>;
-    /**
-     * The cookie of the request. Only available if the cookie middleware is used.
-     */
-    cookie: (name: string) => string | undefined;
-    /**
-     * The ip address of the request.
-     * Tries to get the ip address from the `x-forwarded-for` header. If not available, it will use the remote address from the request.
-     */
-    ip?: string;
-    /**
-     * The files of the request. Only available for multipart/form-data requests and if the file parser middleware is used.
-     */
-    files: FormFile[];
-    /**
-     * The parameters of the request.
-     */
-    params: Record<string, string>;
-    /**
-     * The query parameters of the request.
-     */
-    query: Record<string, string>;
-    /**
-     * The raw body of the request. Only available for POST, PUT, PATCH and DELETE requests.
-     */
-    rawBody?: ArrayBuffer;
-    private _id;
-    /**
-     * The id of the request.
-     */
-    get id(): string;
-    /**
-     * The parsed body of the request
-     */
-    body: any;
-    /**
-     * The validated body of the request.
-     * @param inputSchema - The schema to validate the body against.
-     * @param safe - If true, the function will return the original body if the validation fails instead of throwing an error.
-     */
-    validate<T extends TSchema$1>(inputSchema: T | ((schema: typeof Type) => T), safe?: boolean): Static<T>;
-    /**
-     * Validates the query string of the request.
-     */
-    validateQuery<T extends TSchema$1>(inputSchema: T | ((schema: typeof Type) => T), safe?: boolean): Static<T>;
-    /**
-     * Validates the body and query string of the request.
-     */
-    validateAll<T extends TSchema$1>(inputSchema: T | ((schema: typeof Type) => T), safe?: boolean): Static<T>;
-}
-
-/**
- * Cookie options for setting cookies
- */
-type CookieOptions = {
-    /**
-     * Domain for the cookie
-     */
-    domain?: string;
-    /**
-     * Path for the cookie
-     */
-    path?: string;
-    /**
-     * Expiration date for the cookie
-     */
-    expires?: Date;
-    /**
-     * Max age in seconds for the cookie
-     */
-    maxAge?: number;
-    /**
-     * Whether the cookie is secure (HTTPS only)
-     */
-    secure?: boolean;
-    /**
-     * Whether the cookie is HTTP only
-     */
-    httpOnly?: boolean;
-    /**
-     * SameSite attribute for the cookie
-     */
-    sameSite?: "Strict" | "Lax" | "None";
-    /**
-     * Whether the cookie should be signed
-     */
-    signed?: boolean;
-    /**
-     * Priority for the cookie
-     */
-    priority?: "Low" | "Medium" | "High";
-};
-/**
- * Options for the cookie middleware
- */
-type CookieMiddlewareOptions = {
-    /**
-     * Secret key for signing cookies (required if using signed cookies)
-     */
-    secret?: string;
-    /**
-     * Default options for all cookies set by this middleware
-     */
-    defaults?: CookieOptions;
-    /**
-     * Whether to enable cookie parsing (defaults to true)
-     */
-    parse?: boolean;
-    /**
-     * Whether to enable cookie signing (defaults to false)
-     */
-    sign?: boolean;
-};
-
-/**
- * The response object.
- * This is the main object that is passed to the handler function.
- * It contains the response body, status, headers, etc.
- * It also contains the methods to send the response.
- */
-declare class Response {
-    /**
-     * The status of the response
-     */
-    responseStatus: number;
-    /**
-     * The headers of the response
-     */
-    headers: Record<string, string>;
-    /**
-     * The body of the response
-     */
-    private body;
-    constructor(status?: number);
-    /**
-     * Set a header for the response
-     */
-    setHeader(key: string, value: string): this;
-    /**
-     * Set the status of the response, status defaults to 200
-     */
-    status(status: number): this;
-    /**
-     * Send a response with the given body, tries to determine the content type based on the body type, status defaults to 200
-     * @warning If cannot determine the content type, it will be sent as is
-     */
-    send(body: any): void;
-    /**
-     * Send a response with the given body without any content type or encoding (as is), status defaults to 200
-     */
-    raw(body: any): void;
-    /**
-     * Send a response with the given text, status defaults to 200
-     */
-    text(body: string): void;
-    /**
-     * Send a response with the given JSON, status defaults to 200
-     */
-    json<T extends Record<string, unknown> | Array<unknown>>(body: T): void;
-    /**
-     * Send a response with the given HTML, status defaults to 200
-     */
-    html(body: string): void;
-    /**
-     * Send a response with the given XML, status defaults to 200
-     */
-    xml(body: string): void;
-    /**
-     * Send a response with the given binary with Content-Type of application/octet-stream header, status defaults to 200
-     */
-    download(body: Uint8Array): void;
-    /**
-     * Send a response with the given file, status defaults to 200
-     */
-    file(pathToFile: string): void;
-    /**
-     * 2XX Success
-     */
-    /**
-     * 200 OK
-     */
-    ok(body?: any): void;
-    /**
-     * 201 Created
-     */
-    created(body?: any): void;
-    /**
-     * 202 Accepted
-     */
-    accepted(body?: any): void;
-    /**
-     * 204 No Content
-     */
-    noContent(): void;
-    /**
-     * 206 Partial Content
-     */
-    partialContent(body?: any): void;
-    /**
-     * 3XX Redirection
-     */
-    /**
-     * 300 Multiple Choices
-     */
-    multipleChoices(url: string): void;
-    redirect(url: string): void;
-    /**
-     * 301 Moved Permanently
-     */
-    movedPermanently(url: string): void;
-    /**
-     * 302 Found (Temporary Redirect)
-     */
-    found(url: string): void;
-    /**
-     * 303 See Other
-     */
-    seeOther(url: string): void;
-    /**
-     * 304 Not Modified
-     */
-    notModified(): void;
-    /**
-     * 307 Temporary Redirect
-     */
-    temporaryRedirect(url: string): void;
-    /**
-     * 308 Permanent Redirect
-     */
-    permanentRedirect(url: string): void;
-    /**
-     * 4XX Client Errors
-     */
-    /**
-     * 400 Bad Request
-     */
-    badRequest(body?: any): void;
-    /**
-     * 401 Unauthorized
-     */
-    unauthorized(body?: any): void;
-    /**
-     * 403 Forbidden
-     */
-    forbidden(body?: any): void;
-    /**
-     * 404 Not Found
-     */
-    notFound(body?: any): void;
-    /**
-     * 405 Method Not Allowed
-     */
-    methodNotAllowed(body?: any): void;
-    /**
-     * 406 Not Acceptable
-     */
-    notAcceptable(body?: any): void;
-    /**
-     * 409 Conflict
-     */
-    conflict(body?: any): void;
-    /**
-     * 410 Gone
-     */
-    gone(body?: any): void;
-    /**
-     * 413 Payload Too Large
-     */
-    payloadTooLarge(body?: any): void;
-    /**
-     * 415 Unsupported Media Type
-     */
-    unsupportedMediaType(body?: any): void;
-    /**
-     * 422 Unprocessable Entity
-     */
-    unprocessableEntity(body?: any): void;
-    /**
-     * 429 Too Many Requests
-     */
-    tooManyRequests(body?: any): void;
-    /**
-     * 5XX Server Errors
-     */
-    internalServerError(body?: any): void;
-    /**
-     * 501 Not Implemented
-     */
-    notImplemented(body?: any): void;
-    /**
-     * 502 Bad Gateway
-     */
-    badGateway(body?: any): void;
-    /**
-     * 503 Service Unavailable
-     */
-    serviceUnavailable(body?: any): void;
-    /**
-     * 504 Gateway Timeout
-     */
-    gatewayTimeout(body?: any): void;
-    /**
-     * 505 HTTP Version Not Supported
-     */
-    httpVersionNotSupported(body?: any): void;
-    /**
-     * Set a cookie for the response, does nothing if the cookie middleware is not registered
-     */
-    cookie(_name: string, _value: string, _options?: CookieOptions): void;
-    /**
-     * Clear a cookie for the response, does nothing if the cookie middleware is not registered
-     */
-    clearCookie(_name: string, _options?: CookieOptions): void;
-    /**
-     * Get the body of the response
-     */
-    getBody(): any;
-}
-
-type DelHandler = (req: Request$1, res: Response, ...args: any[]) => any;
-/**
- * Decorator to mark an handler for a DELETE request
- * @param path - The path of the route
- * @param options - The options for the route
- * @warning Must receive the request and response as the first two arguments or it might not work as expected.
- * @example
- * ```ts
- * import { del, controller, Request, Response } from "balda";
- *
- * @controller("/api")
- * class MyController {
- *   @del("/")
- *   async handler(req: Request, res: Response) {
- *     // ...
- *   }
- * }
- * ```
- */
-declare const del: (path: string, options?: SwaggerRouteOptions) => <T extends DelHandler>(target: any, propertyKey: string, descriptor: PropertyDescriptor) => TypedPropertyDescriptor<T>;
-
-type GetHandler = (req: Request$1, res: Response, ...args: any[]) => any;
-/**
- * Decorator to mark an handler for a GET request
- * @param path - The path of the route
- * @param options - The options for the route
- * @warning Must receive the request and response as the first two arguments or it might not work as expected.
- * @example
- * ```ts
- * import { get, controller, Request, Response } from "balda";
- *
- * @controller("/api")
- * class MyController {
- *   @get("/")
- *   async handler(req: Request, res: Response) {
- *     // ...
- *   }
- * }
- * ```
- */
-declare const get: (path: string, options?: SwaggerRouteOptions) => <T extends GetHandler>(target: any, propertyKey: string, descriptor: PropertyDescriptor) => TypedPropertyDescriptor<T>;
-
-type PatchHandler = (req: Request$1, res: Response, ...args: any[]) => any;
-/**
- * Decorator to mark an handler for a PATCH request
- * @param path - The path of the route
- * @param options - The options for the route
- * @warning Must receive the request and response as the first two arguments or it might not work as expected.
- * @example
- * ```ts
- * import { patch, controller, Request, Response } from "balda";
- *
- * @controller("/api")
- * class MyController {
- *   @patch("/")
- *   async handler(req: Request, res: Response) {
- *     // ...
- *   }
- * }
- * ```
- */
-declare const patch: (path: string, options?: SwaggerRouteOptions) => <T extends PatchHandler>(target: any, propertyKey: string, descriptor: PropertyDescriptor) => TypedPropertyDescriptor<T>;
-
-type PostHandler = (req: Request$1, res: Response, ...args: any[]) => any;
-/**
- * Decorator to mark an handler for a POST request
- * @param path - The path of the route
- * @param options - The options for the route
- * @warning Must receive the request and response as the first two arguments or it might not work as expected.
- * @example
- * ```ts
- * import { post, controller, Request, Response } from "balda";
- *
- * @controller("/api")
- * class MyController {
- *   @post("/")
- *   async handler(req: Request, res: Response) {
- *     // ...
- *   }
- * }
- * ```
- */
-declare const post: (path: string, options?: SwaggerRouteOptions) => <T extends PostHandler>(target: any, propertyKey: string, descriptor: PropertyDescriptor) => TypedPropertyDescriptor<T>;
-
-type PutHandler = (req: Request$1, res: Response, ...args: any[]) => any;
-/**
- * Decorator to mark an handler for a PUT request
- * @param path - The path of the route
- * @param options - The options for the route
- * @warning Must receive the request and response as the first two arguments or it might not work as expected.
- * @example
- * ```ts
- * import { put, controller, Request, Response } from "balda";
- *
- * @controller("/api")
- * class MyController {
- *   @put("/")
- *   async handler(req: Request, res: Response) {
- *     // ...
- *   }
- */
-declare const put: (path: string, options?: SwaggerRouteOptions) => <T extends PutHandler>(target: any, propertyKey: string, descriptor: PropertyDescriptor) => TypedPropertyDescriptor<T>;
-
-/**
- * The next function.
- * This is the function that is passed to the handler function.
- * It has a pointer to the next middleware or handler function of the middleware chain.
- */
-type NextFunction = () => void | Promise<void>;
-
-type RunTimeType = "bun" | "node" | "deno";
-
-type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
-type RuntimeServerMap<T extends RunTimeType> = T extends "node" ? Server$1 : never;
-type ServerRouteMiddleware = (req: Request$1, res: Response, next: NextFunction) => void | Promise<void>;
-type ServerRouteHandler = (req: Request$1, res: Response) => void | Promise<void>;
-type ServerListenCallback = ({ port, host, url, }: {
-    port: number;
-    host: string;
-    url: string;
-}) => void;
-/**
- * Custom bun fetch call to be used as an hook inside Bun.serve method
- */
-type CustomBunFetch = (...options: Parameters<Bun.ServeOptions["fetch"]>) => Promise<void> | void;
-/**
- * Custom deno fetch call to be used as an hook inside Deno.serve method
- */
-type CustomDenoFetch = (...options: Parameters<Parameters<typeof Deno.serve>[0]["handler"]>) => Promise<void> | void;
-/**
- * The options for the server tap function, allows you to interact with the server behavior before it is used to listen for incoming requests
- */
-type ServerTapOptionsBuilder<T extends RunTimeType> = T extends "node" ? (req: Omit<IncomingMessage, "url">) => Promise<void> : T extends "bun" ? Partial<Parameters<typeof Bun.serve>[0]> & {
-    fetch?: CustomBunFetch;
-} : T extends "deno" ? Partial<Omit<Parameters<typeof Deno.serve>[0], "handler">> & {
-    handler?: CustomDenoFetch;
-} : never;
-type BunTapOptions = {
-    type: "bun";
-    options: ServerTapOptionsBuilder<"bun">;
-};
-type NodeTapOptions = {
-    type: "node";
-    options: ServerTapOptionsBuilder<"node">;
-};
-type DenoTapOptions = {
-    type: "deno";
-    options: ServerTapOptionsBuilder<"deno">;
-};
-type ServerTapOptions = BunTapOptions | NodeTapOptions | DenoTapOptions;
-
-/**
- * Decorator to mark a middleware for a route or a controller class
- */
-declare const middleware: (middleware: ServerRouteMiddleware | ServerRouteMiddleware[]) => (target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => any;
-
-interface CustomValidationError {
-    status?: number;
-    message?: string;
-}
-interface ValidationOptions {
-    /**
-     * The schema to validate the request body against
-     */
-    body?: TSchema$1;
-    /**
-     * The schema to validate the query parameters against
-     */
-    query?: TSchema$1;
-    /**
-     * The schema to validate both body and query against
-     */
-    all?: TSchema$1;
-    /**
-     * Whether to use safe validation (returns original data if validation fails instead of throwing)
-     * @default false
-     */
-    safe?: boolean;
-}
-
-declare const validate: {
-    (options: ValidationOptions & {
-        customError?: CustomValidationError;
-    }): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-    query(schema: TSchema$1, customError?: CustomValidationError): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-    body(schema: TSchema$1, customError?: CustomValidationError): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-    all(schema: TSchema$1, customError?: CustomValidationError): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-};
-
-/**
- * Options for helmet middleware
- */
-interface HelmetOptions {
-    dnsPrefetchControl?: boolean;
-    frameguard?: boolean | {
-        action: "DENY" | "SAMEORIGIN" | string;
-    };
-    hsts?: boolean | {
-        maxAge?: number;
-        includeSubDomains?: boolean;
-        preload?: boolean;
-    };
-    contentTypeOptions?: boolean;
-    ieNoOpen?: boolean;
-    xssFilter?: boolean;
-    referrerPolicy?: false | string;
-    crossOriginResourcePolicy?: false | string;
-    crossOriginOpenerPolicy?: false | string;
-    crossOriginEmbedderPolicy?: false | string;
-    contentSecurityPolicy?: false | string;
-}
-
-type LoggerOptions = Parameters<typeof pino>[0];
-
-interface LogOptions {
-    /**
-     * Whether to log the request.
-     * @default true
-     */
-    logRequest?: boolean;
-    /**
-     * What to log for the request.
-     * @default true for all properties
-     */
-    requestPayload?: {
-        method?: boolean;
-        url?: boolean;
-        ip?: boolean;
-        headers?: boolean;
-        /** Only json objects and strings are logged */
-        body?: boolean;
-    };
-    /**
-     * Whether to log the response.
-     * @default true
-     */
-    logResponse?: boolean;
-    /**
-     * Whether to log the response body.
-     * @default false
-     */
-    responsePayload?: {
-        status?: boolean;
-        headers?: boolean;
-        body?: boolean;
-    };
-    /**
-     * What to log for the response.
-     * @default true for all properties
-     */
-    pinoOptions?: LoggerOptions;
-}
-
-type StorageStrategy = "memory" | "custom";
-type BaseRateLimiterOptions = {
-    /**
-     * The number of requests per window
-     * @default 100
-     */
-    limit?: number;
-    /**
-     * The message to return when the rate limit is exceeded
-     * @default "ERR_RATE_LIMIT_EXCEEDED"
-     */
-    message?: string;
-    /**
-     * The status code to return when the rate limit is exceeded
-     * @default 429
-     */
-    statusCode?: number;
-    /**
-     * The storage strategy to use
-     * @default "memory"
-     */
-    storageStrategy?: StorageStrategy;
-};
-/**
- * Key Strategy
- */
-type IpRateLimiterOptions = {
-    /**
-     * The type of rate limiter
-     */
-    type: "ip";
-} & BaseRateLimiterOptions;
-type CustomRateLimiterOptions = {
-    /**
-     * The type of rate limiter
-     */
-    type: "custom";
-    /**
-     * Generate a key for the rate limiter from the request (e.g. user id, email, etc.)
-     */
-    key: (req: Request$1) => string;
-    /**
-     * The storage strategy to use
-     * @default "memory"
-     */
-    storageStrategy?: StorageStrategy;
-} & BaseRateLimiterOptions;
-/**
- * Memory Storage Strategy
- */
-type MemoryStorageStrategy = {
-    /**
-     * The type of storage strategy
-     */
-    type: "memory";
-    /**
-     * The window in milliseconds
-     * @default 60000
-     */
-    windowMs?: number;
-};
-/**
- * Custom Storage Strategy
- */
-type CustomStorageStrategy = {
-    /**
-     * The type of storage strategy
-     */
-    type: "custom";
-    /**
-     * Set a value in the storage
-     */
-    set: (key: string, value: any) => Promise<void>;
-    /**
-     * Get a value from the storage
-     */
-    get: (key: string) => Promise<any>;
-};
-type StorageOptions = MemoryStorageStrategy | CustomStorageStrategy;
-/**
- * Rate limiter options
- */
-type RateLimiterKeyOptions = IpRateLimiterOptions | CustomRateLimiterOptions;
-
-type CorsMethods = "GET" | "POST" | "PUT" | "DELETE" | "OPTIONS" | "PATCH" | "HEAD";
-/**
- * Options for CORS middleware, similar to Express.js
- */
-type CorsOptions = {
-    /**
-     * Configures the Access-Control-Allow-Origin CORS header, defaults to '*'
-     */
-    origin?: string | RegExp | (string | RegExp)[];
-    /**
-     * Configures the Access-Control-Allow-Methods CORS header. Defaults to 'GET,HEAD,PUT,PATCH,POST,DELETE'.
-     */
-    methods?: CorsMethods[] | string;
-    /**
-     * Configures the Access-Control-Allow-Headers CORS header. Defaults to allowing all requested headers.
-     */
-    allowedHeaders?: string[] | string;
-    /**
-     * Configures the Access-Control-Expose-Headers CORS header. Defaults to none.
-     */
-    exposedHeaders?: string[] | string;
-    /**
-     * Configures the Access-Control-Allow-Credentials CORS header. Defaults to false.
-     */
-    credentials?: boolean;
-    /**
-     * Configures the Access-Control-Max-Age CORS header. Defaults to undefined (not sent).
-     */
-    maxAge?: number;
-    /**
-     * Pass the CORS preflight response to the next handler. Defaults to false (ends response).
-     */
-    preflightContinue?: boolean;
-    /**
-     * Provides a status code to use for successful OPTIONS requests, if preflightContinue is false. Defaults to 204.
-     */
-    optionsSuccessStatus?: number;
-};
-
-interface JsonOptions {
-    /**
-     * The maximum size of the JSON body in bytes.
-     * If the body is larger than this limit, the request will be rejected.
-     * Default: 5mb
-     */
-    sizeLimit?: number;
-    /**
-     * If true, the JSON body will be parsed as an empty object if it is empty.
-     * Default: false (body will be undefined)
-     */
-    parseEmptyBodyAsObject?: boolean;
-    /**
-     * The encoding to use when decoding the request body.
-     * Default: "utf-8"
-     */
-    encoding?: TextDecoderEncoding;
-    /**
-     * The custom error message to return when the JSON body is too large.
-     * Default: response with status 413 and body { message: "ERR_REQUEST_BODY_TOO_LARGE" }
-     */
-    customErrorMessage?: {
-        status?: number;
-        message?: string;
-    };
-}
-/**
- * Supported text encodings for TextDecoder.
- * Based on the WHATWG Encoding Standard.
- */
-type TextDecoderEncoding = "utf-8" | "utf-16le" | "utf-16be" | "gbk" | "gb18030" | "big5" | "euc-jp" | "iso-2022-jp" | "shift-jis" | "euc-kr" | "iso-2022-kr" | "iso-8859-1" | "iso-8859-2" | "iso-8859-3" | "iso-8859-4" | "iso-8859-5" | "iso-8859-6" | "iso-8859-7" | "iso-8859-8" | "iso-8859-9" | "iso-8859-10" | "iso-8859-13" | "iso-8859-14" | "iso-8859-15" | "iso-8859-16" | "windows-1250" | "windows-1251" | "windows-1252" | "windows-1253" | "windows-1254" | "windows-1255" | "windows-1256" | "windows-1257" | "windows-1258" | "x-mac-cyrillic" | "x-mac-greek" | "x-mac-icelandic" | "x-mac-latin2" | "x-mac-roman" | "x-mac-turkish" | "koi8-r" | "koi8-u";
-
-declare class MockResponse<T = any> {
-    private readonly response;
-    constructor(response: Response);
-    body(): T;
-    statusCode(): number;
-    headers(): Record<string, string>;
-    assertStatus(status: number): this;
-    assertHeader(header: string, value: string): this;
-    assertHeaderExists(header: string): this;
-    assertHeaderNotExists(header: string): this;
-    assertBodySubset(subset: Partial<T>): this;
-    assertBodyDeepEqual(expected: T): this;
-    assertBodyNotSubset(subset: Partial<T>): this;
-    assertBodyNotDeepEqual(expected: T): this;
-    assertCustom(assertion: (response: Response) => void): this;
-    private assertSubset;
-    private assertDeepEqual;
-    private assertNotSubset;
-    private assertNotDeepEqual;
-    private assertArraySubset;
-    private assertArrayDeepEqual;
-    private isObject;
-}
-
-/**
- * The options for the mock server, only one of body, formData, urlencoded can be provided
- */
-interface MockServerOptions {
-    /**
-     * The body of the request, if formData is provided, it will be ignored
-     */
-    body?: any;
-    /**
-     * The form data of the request
-     */
-    formData?: FormData;
-    /**
-     * The urlencoded body of the request
-     */
-    urlencoded?: Record<string, string>;
-    /**
-     * The headers of the request
-     */
-    headers?: Record<string, string>;
-    /**
-     * The query parameters of the request, if provided, they will be merged with the query parameters from the path (precedence is given to the query parameters provided here)
-     */
-    query?: Record<string, string>;
-    /**
-     * The cookies of the request
-     */
-    cookies?: Record<string, string>;
-    /**
-     * The ip of the request
-     */
-    ip?: string;
-}
-
-/**
- * Allows to mock server requests without needing to start the server, useful for testing purposes
- */
-declare class MockServer {
-    private readonly server;
-    constructor(server: Server);
-    /**
-     * Simulates an HTTP request without making an actual network call, useful for testing purposes
-     * Executes the middleware chain and handler of the route
-     * @param method - The HTTP method (GET, POST, PUT, DELETE, PATCH)
-     * @param path - The request path
-     * @param options - Request options including body, headers, query params, etc.
-     * @throws {Error} - If more than one of body, formData, urlencoded is provided
-     */
-    request<T>(method: HttpMethod, path: string, options?: MockServerOptions): Promise<MockResponse<T>>;
-    get<T>(path: string, options?: Omit<MockServerOptions, "body" | "formData" | "urlencoded">): Promise<MockResponse<T>>;
-    post<T>(path: string, options?: MockServerOptions): Promise<MockResponse<T>>;
-    put<T>(path: string, options?: MockServerOptions): Promise<MockResponse<T>>;
-    patch<T>(path: string, options?: MockServerOptions): Promise<MockResponse<T>>;
-    delete<T>(path: string, options?: Omit<MockServerOptions, "body" | "formData">): Promise<MockResponse<T>>;
-    /**
-     * Converts FormData to a proper multipart/form-data body with boundaries
-     */
-    private formDataToMultipart;
-    private validateOptions;
-}
-
-/**
- * Options for URL-encoded middleware
- */
-type UrlEncodedOptions = {
-    /**
-     * The maximum size of the URL-encoded body in bytes. Defaults to 1MB.
-     */
-    limit?: number;
-    /**
-     * Whether to parse extended syntax (objects and arrays). Defaults to false.
-     */
-    extended?: boolean;
-    /**
-     * The character encoding to use when parsing. Defaults to 'utf8'.
-     */
-    charset?: string;
-    /**
-     * Whether to allow empty values. Defaults to true.
-     */
-    allowEmpty?: boolean;
-    /**
-     * Maximum number of parameters to parse. Defaults to 1000.
-     */
-    parameterLimit?: number;
-};
-
-/**
- * Swagger plugin that serves the swagger UI and JSON specification, by default the UI will be available at /docs and the JSON specification at /docs/json
- * @warning The json specification is always available at /${globalOptions.path}/json
- * @internal
- */
-declare const swagger: (globalOptions?: SwaggerGlobalOptions | boolean) => void;
-
-type CronSchedule = {
-    name: string;
-    args: Parameters<typeof nodeCron.schedule>;
-};
-type CronScheduleParams = Parameters<typeof nodeCron.schedule>;
-
-declare class CronService {
-    static scheduledJobs: CronSchedule[];
-    /**
-     * @description Schedule a cron job.
-     * @internal
-     * @example
-     * CronService.register('test', '0 0 * * *', () => {
-     *   console.log('test');
-     * }, {
-     *   timezone: 'Europe/Istanbul',
-     * });
-     */
-    static register(name: string, ...args: CronScheduleParams): void;
-    /**
-     * @description Start the cron scheduler.
-     */
-    static run(): Promise<void>;
-    /**
-     * @description Main error handler for cron jobs. You can write your own error handler by overriding this static method for example with sentry.
-     */
-    static globalErrorHandler(context: TaskContext): void;
-    /**
-     * @description Import all cron jobs from the app/cron/schedules directory
-     */
-    static massiveImportCronJobs(cronJobPatterns: string[]): Promise<void>;
-}
-
-type ServerPlugin = {
-    cors?: CorsOptions;
-    json?: JsonOptions;
-    static?: string;
-    fileParser?: FilePluginOptions;
-    helmet?: HelmetOptions;
-    cookie?: CookieMiddlewareOptions;
-    log?: LogOptions;
-    urlencoded?: UrlEncodedOptions;
-    rateLimiter?: {
-        keyOptions?: RateLimiterKeyOptions;
-        storageOptions?: StorageOptions;
-    };
-};
-interface ServerOptions {
-    /** The port to listen on, defaults to 80 */
-    port?: number;
-    /** The hostname to listen on, defaults to 0.0.0.0 */
-    host?: string;
-    /** Controller patterns to match, defaults to an empty array */
-    controllerPatterns?: string[];
-    /** Basic plugins to apply to the server, by default no plugins are applied */
-    plugins?: ServerPlugin;
-    /** The tap options to interact with the underlying server connector before it is used to listen for incoming requests */
-    tapOptions?: ServerTapOptions;
-    /**
-     * The swagger options to apply to the server, by default swagger plugin is applied with standard options, you can pass a boolean to enable or disable the plugin or you can pass an object to apply custom options to the plugin
-     * @example
-     * ```ts
-     * const server = new Server({
-     *   swagger: true,
-     * });
-     * ```
-     */
-    swagger?: Parameters<typeof swagger>[0] | boolean;
-}
-type ServerErrorHandler = (req: Request, res: Response, next: NextFunction, error: Error) => void | Promise<void>;
-interface ServerInterface {
-    /**
-     * Whether the server is listening for requests
-     */
-    isListening: boolean;
-    /**
-     * The url of the server
-     */
-    url: string;
-    /**
-     * The port of the server
-     */
-    port: number;
-    /**
-     * The host of the server
-     */
-    host: string;
-    /**
-     * Settings applied before server is listening, this is used to tap into the server connector for the current runtime and modify it before it is used to listen for incoming requests
-     * @warning Must be used before `listen` method
-     */
-    tapOptions?: ServerTapOptions;
-    /**
-     * The path to the temporary directory, you can append a path to the temporary directory to get a new path.
-     * It uses the current working directory of the runtime to get the base path.
-     * @example
-     * ```ts
-     * server.tmpPath("my-app"); // -> ${cwd}/tmp/my-app
-     * ```
-     */
-    tmpDir: (...append: string[]) => string;
-    /**
-     * Adds a GET route to the server, useful for defining simple global routes, use decorators to define more complex routes
-     */
-    get: (...args: any[]) => void;
-    /**
-     * Adds a POST route to the server, useful for defining simple global routes, use decorators to define more complex routes
-     */
-    post: (...args: any[]) => void;
-    /**
-     * Adds a PUT route to the server, useful for defining simple global routes, use decorators to define more complex routes
-     */
-    put: (...args: any[]) => void;
-    /**
-     * Adds a PATCH route to the server, useful for defining simple global routes, use decorators to define more complex routes
-     */
-    patch: (...args: any[]) => void;
-    /**
-     * Adds a DELETE route to the server, useful for defining simple global routes, use decorators to define more complex routes
-     */
-    delete: (...args: any[]) => void;
-    /**
-     * Get the node server instance, you must be using node runtime to use this method
-     * @throws if the runtime is not node
-     */
-    getNodeServer: () => RuntimeServerMap<"node">;
-    /**
-     * Embed the given key into the server instance, this is useful for embedding the server with custom context inside the server instance, you can extend the server with your own properties to type it
-     * @param key - The key to embed
-     * @param value - The value to embed
-     * @warning There are some keys that are protected and cannot be embedded, you can find the list of protected keys in the PROTECTED_KEYS constant
-     * @throws An error if the key is already defined in the server instance or if the key is protected
-     * @example
-     * ```typescript
-     * // For better type safety, you can declare a module for the server interface
-     * declare module "balda" {
-     *   interface ServerInterface {
-     *     myCustomProperty: string;
-     *   }
-     * }
-     *
-     * server.embed("myCustomProperty", "myCustomValue");
-     * console.log(server.myCustomProperty); // Type safe if ServerInterface is extended
-     * ```
-     */
-    embed: (key: string, value: any) => void;
-    /**
-     * Register a signal event listener to the server, this is useful for handling signals like SIGINT, SIGTERM, etc.
-     * @param event - The signal event to listen for
-     * @param cb - The callback to be called when the signal event is received
-     */
-    on: (event: SignalEvent, cb: () => void) => void;
-    /**
-     * Register a global middleware to be applied to all routes after the listener is bound, the middleware is applied in the order it is registered
-     */
-    use: (middleware: ServerRouteMiddleware) => void;
-    /**
-     * Set the error handler for the server
-     * @param errorHandler - The error handler to be applied to all routes
-     */
-    setErrorHandler: (errorHandler?: ServerErrorHandler) => void;
-    /**
-     * Binds the server to the port and hostname defined in the serverOptions, meant to be called only once
-     * @warning All routes defined with decorators are defined on this method just before the server starts listening for requests
-     */
-    listen: (cb?: ServerListenCallback) => void;
-    /**
-     * Closes the server and frees the port
-     */
-    close: () => Promise<void>;
-    /**
-     * Get a mock server instance, useful for testing purposes
-     */
-    getMockServer: () => Promise<MockServer>;
-    /**
-     * Exit current runtime process with the given code based on the current runtime
-     * @param code - The code to exit with, defaults to 0
-     * @example
-     * ```typescript
-     * server.exit(1); // If node process.exit(1) is called
-     * server.exit(); // If deno Deno.exit(0) is called
-     * ```
-     */
-    exit: (code?: number) => void;
-    /**
-     * Sets the global cron error handler
-     * @param globalErrorHandler - The global cron error handler
-     */
-    setGlobalCronErrorHandler: (globalErrorHandler: (...args: Parameters<(typeof CronService)["globalErrorHandler"]>) => void) => void;
-    /**
-     * Starts the registered cron jobs
-     * @param cronJobPatterns - The cron job patterns to that will be imported and registered before starting the cron jobs
-     * @param onStart - The callback to be called when the cron jobs are started
-     */
-    startRegisteredCrons: (cronJobPatterns?: string[], onStart?: () => void) => Promise<void>;
-}
-type StandardMethodOptions = {
-    middlewares?: ServerRouteMiddleware[] | ServerRouteMiddleware;
-    swagger?: SwaggerRouteOptions;
-};
-type SignalEvent = Deno.Signal | NodeJS.Signals;
-
-/**
- * The server class that is used to create and manage the server
- */
-declare class Server implements ServerInterface {
-    isListening: boolean;
-    private wasInitialized;
-    private serverConnector;
-    private globalMiddlewares;
-    private options;
-    private controllerImportBlacklistedPaths;
-    /**
-     * The constructor for the server
-     * @warning Routes will only be defined after calling the `listen` method so you're free to define middlewares before calling it
-     * @param options - The options for the server
-     * @param options.port - The port to listen on, defaults to 80
-     * @param options.host - The hostname to listen on, defaults to 0.0.0.0
-     * @param options.controllerPatterns - The patterns to match for controllers, defaults to an empty array
-     * @param options.plugins - The plugins to apply to the server, by default no plugins are applied, plugins are applied in the order they are defined in the options
-     * @param options.logger - The logger to use for the server, by default a default logger is used
-     * @param options.tapOptions - Options fetch to the runtime server before the server is up and running
-     */
-    constructor(options?: ServerOptions);
-    get url(): string;
-    get port(): number;
-    get host(): string;
-    tmpDir(...append: string[]): string;
-    get(path: string, handler: ServerRouteHandler): void;
-    get(path: string, options: StandardMethodOptions, handler: ServerRouteHandler): void;
-    post(path: string, handler: ServerRouteHandler): void;
-    post(path: string, options: StandardMethodOptions, handler: ServerRouteHandler): void;
-    patch(path: string, handler: ServerRouteHandler): void;
-    patch(path: string, options: StandardMethodOptions, handler: ServerRouteHandler): void;
-    put(path: string, handler: ServerRouteHandler): void;
-    put(path: string, options: StandardMethodOptions, handler: ServerRouteHandler): void;
-    delete(path: string, handler: ServerRouteHandler): void;
-    delete(path: string, options: StandardMethodOptions, handler: ServerRouteHandler): void;
-    getNodeServer(): RuntimeServerMap<"node">;
-    embed(key: string, value: any): void;
-    exit(code?: number): void;
-    on(event: SignalEvent, cb: () => void): void;
-    on(event: string, cb: () => void): void;
-    use(...middlewares: ServerRouteMiddleware[]): void;
-    setErrorHandler(errorHandler?: ServerErrorHandler): void;
-    setGlobalCronErrorHandler(globalErrorHandler: (...args: Parameters<(typeof CronService)["globalErrorHandler"]>) => void): void;
-    startRegisteredCrons: (cronJobPatterns?: string[], onStart?: () => void) => Promise<void>;
-    listen(cb?: ServerListenCallback): void;
-    close(): Promise<void>;
-    /**
-     * Returns a mock server instance that can be used to test the server without starting it
-     * It will import the controllers and apply the plugins to the mock server
-     */
-    getMockServer(): Promise<MockServer>;
-    private importControllers;
-    private extractOptionsAndHandlerFromRouteRegistration;
-    private applyPlugins;
-    /**
-     * Initializes the server by importing the controllers and applying the plugins, it's idempotent, it will not re-import the controllers or apply the plugins if the server was already initialized (e.g. mockServer init)
-     * @internal
-     */
-    private bootstrap;
-    /**
-     * Registers a not found route for all routes that are not defined
-     * @internal
-     */
-    private registerNotFoundRoutes;
-}
-
-/**
- * CORS plugin
- * @param options CORS options (all optional)
- */
-declare const cors: (options?: CorsOptions) => ServerRouteMiddleware;
-
-/**
- * Middleware to parse the JSON body of the request. GET, DELETE and OPTIONS requests are not parsed.
- * @param options - The options for the JSON middleware.
- */
-declare const json: (options?: JsonOptions) => ServerRouteMiddleware;
-
-/**
- * Creates a static file serving middleware and registers all routes for the given path (path + "/*")
- * @param path - The api path to serve static files from.
- * @example 'public' -> localhost:3000/public/index.html will search for public/index.html in the current directory
- */
-declare const serveStatic: (path?: string, swaggerOptions?: SwaggerRouteOptions) => ServerRouteMiddleware;
-declare function getContentType(ext: string): string;
-
-/**
- * Cookie middleware for parsing and setting cookies, must be used in order to use the cookie methods on the request and response objects
- * @param options Cookie middleware options
- */
-declare const cookie: (options?: CookieMiddlewareOptions) => ServerRouteMiddleware;
-
-/**
- * Base class for all plugins.
- *
- * Plugins are used to extend the functionality of the server.
- *
- * @example
- * ```ts
- * import { Server, BasePlugin } from "balda";
- *
- * export class MyPlugin extends BasePlugin {
- *   async handle(): Promise<ServerRouteMiddleware> {
- *     return async (req, res, next) => {
- *       console.log("My plugin is running");
- *       await next();
- *     };
- *   }
- * }
- *
- * const server = new Server();
- * server.use(new MyPlugin().handle());
- * ```
- *
- * @abstract
- */
-declare abstract class BasePlugin {
-    abstract handle(...args: any[]): Promise<ServerRouteMiddleware>;
-}
-
-/**
- * Rate limiter plugin
- * Rate limiter is a plugin that limits the number of requests to a resource.
- * It can be used to protect a resource from abuse.
- * @param keyOptions Rate limiter key options, tells the middleware how to retrieve the key from the request in to discriminate what to rate limit (all optional, defaults to ip)
- * @param storageOptions Rate limiter storage options, tells the middleware how to store the rate limit data (all optional, defaults to memory)
- */
-declare const rateLimiter: (keyOptions?: RateLimiterKeyOptions, storageOptions?: StorageOptions) => ServerRouteMiddleware;
-
-/**
- * Logs the request and response of the handler, can be set both on a specific route or on a global middleware.
- * @warning Only json objects and strings are logged from the request and response.
- */
-declare const log: (options?: LogOptions) => ServerRouteMiddleware;
-
-/**
- * Middleware to handle multipart/form-data file uploads.
- *  - Validates each file against the given `FilePluginOptions` (currently only size limit).
- *  - Stores every uploaded file in a runtime-agnostic temporary directory and exposes them via `req.files` & `req.file`.
- *  - Cleans the temporary files both after successful handler execution and when an unhandled error bubbles up.
- *  - Can be used both as a global middleware to check all incoming requests for files and as a route middleware to check only the files for a specific route
- */
-declare const fileParser: (options?: FilePluginOptions) => ServerRouteMiddleware;
-
-/**
- * Sets common HTTP security headers
- * @param options Helmet options (all optional)
- */
-declare const helmet: (options?: HelmetOptions) => ServerRouteMiddleware;
-
-/**
- * URL-encoded form data parser middleware
- * Parses application/x-www-form-urlencoded bodies and populates req.body
- * @param options URL-encoded parsing options
- * @param options.limit The maximum size of the URL-encoded body in bytes. Defaults to 1MB.
- * @param options.extended Whether to parse extended syntax (objects and arrays). Defaults to false.
- * @param options.charset The character encoding to use when parsing. Defaults to 'utf8'.
- * @param options.allowEmpty Whether to allow empty values. Defaults to true.
- * @param options.parameterLimit Maximum number of parameters to parse. Defaults to 1000.
- */
-declare const urlencoded: (options?: UrlEncodedOptions) => ServerRouteMiddleware;
-
-/**
- * Singleton that handles the routing of requests to the appropriate handler(s).
- */
-declare class Router {
-    private trees;
-    private routes;
-    constructor();
-    getRoutes(): Route[];
-    addOrUpdate(method: HttpMethod, path: string, middleware: ServerRouteMiddleware[], handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
-    find(method: string, rawPath: string): {
-        middleware: ServerRouteMiddleware[];
-        handler: ServerRouteHandler;
-        params: Params;
-    } | null;
-    /**
-     * Apply global middlewares to all routes
-     * @param middlewares - The middlewares to apply
-     * @internal
-     */
-    applyGlobalMiddlewaresToAllRoutes(middlewares: ServerRouteMiddleware[]): void;
-}
-
-type Params = Record<string, string>;
-interface Route {
-    method: string;
-    path: string;
-    middleware: ServerRouteMiddleware[];
-    handler: ServerRouteHandler;
-    swaggerOptions?: SwaggerRouteOptions;
-}
-/**
- * The client router is a subset of the router that is used to define routes on library level by the end user.
- */
-type ClientRouter = Omit<Router, "applyGlobalMiddlewaresToAllRoutes">;
-
-/**
- * Main router instance that handles all route registrations inside the balda server
- */
-declare const router: ClientRouter;
-
-export { BasePlugin, type NextFunction, Request$1 as Request, Response, Server, type ServerErrorHandler, type ServerInterface, type ServerOptions, type ServerPlugin, type SignalEvent, type StandardMethodOptions, controller, cookie, cors, del, fileParser, get, getContentType, helmet, json, log, middleware, patch, post, put, rateLimiter, router, serveStatic, urlencoded, validate };