balda 0.0.1

package/lib/index.d.cts

@@ -0,0 +1,3077 @@
+import { schedule, TaskContext } from 'node-cron';
+import { ZodType, ZodAny } from 'zod';
+import { Ajv } from 'ajv';
+import { ServerResponse, IncomingMessage, Server as Server$2 } from 'node:http';
+import { Http2Server } from 'node:http2';
+import { Server as Server$1, ServerOptions as ServerOptions$1 } from 'node:https';
+export { ServerOptions as HttpsServerOptions } from 'node:https';
+import { GraphQLSchema } from 'graphql';
+import { createSchema, createYoga } from 'graphql-yoga';
+import { RequestHandler, Router as Router$1, IRouter } from 'express';
+export { ErrorRequestHandler as ExpressErrorMiddleware, RequestHandler as ExpressMiddleware, NextFunction as ExpressNextFunction, Request as ExpressRequest, Response as ExpressResponse } from 'express';
+import * as pino from 'pino';
+import pino__default, { pino as pino$1 } from 'pino';
+import { Queue, Job } from 'bullmq';
+import PgBoss from 'pg-boss';
+import { SQSClient, SQSClientConfig } from '@aws-sdk/client-sqs';
+import { IClientSubscribeOptions, IClientOptions, IClientPublishOptions, MqttClient } from 'mqtt';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { S3Client } from '@aws-sdk/client-s3';
+
+type CronSchedule = {
+    name: string;
+    args: Parameters<typeof schedule>;
+};
+type CronScheduleParams = Parameters<typeof schedule>;
+
+/**
+ * Decorator to schedule a cron job. Must be applied to a class method. By default, the cron job will not overlap with other cron jobs of the same type.
+ * ```ts
+ * @cron('* * * * *', { timezone: 'Europe/Istanbul' })
+ * async test() {
+ *   console.log('test');
+ * }
+ * ```
+ */
+declare const cron: (schedule: CronScheduleParams[0], options?: CronScheduleParams[2]) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+
+type FlagType = "boolean" | "string" | "number" | "list";
+type InferFlagType<T extends FlagType> = T extends "boolean" ? boolean : T extends "string" ? string : T extends "number" ? number : T extends "list" ? string[] : never;
+type ArgOptions = {
+    /**
+     * The description of the argument.
+     */
+    description?: string;
+    /**
+     * Whether the argument is required.
+     * @default false
+     */
+    required?: boolean;
+    /**
+     * The default value of the argument.
+     */
+    defaultValue?: string;
+    /**
+     * A function to parse the argument value.
+     * @default The value is returned as is.
+     */
+    parse?: (value: string) => string;
+};
+type FlagOptions<T extends FlagType> = {
+    /**
+     * The description of the flag.
+     */
+    description?: string;
+    /**
+     * The type of the flag.
+     */
+    type: T;
+    /**
+     * The name of the flag.
+     * @default The name of the field.
+     */
+    name?: string;
+    /**
+     * The aliases of the flag.
+     */
+    aliases?: string[] | string;
+    /**
+     * The default value of the flag.
+     */
+    defaultValue?: InferFlagType<T>;
+    /**
+     * Whether the flag is required.
+     * @default false
+     */
+    required?: boolean;
+    /**
+     * A function to parse the flag value.
+     * @default The value is returned as is.
+     */
+    parse?: (value: any) => InferFlagType<T>;
+};
+
+declare const VALIDATION_ERROR_SYMBOL = "VALIDATION_ERROR";
+declare const ARG_SYMBOL = "ARG";
+/**
+ * Decorator to mark a field of a command class as an argument.
+ * @param options - The options for the argument.
+ * @warning Arguments are evaluated in the order they are defined in the Command class.
+ */
+declare const arg: (options: ArgOptions) => (target: any, propertyKey: string) => void;
+
+declare const flag: {
+    <T extends FlagType>(options: FlagOptions<T>): (target: any, propertyKey: string) => void;
+    boolean(options: Omit<FlagOptions<"boolean">, "type">): (target: any, propertyKey: string) => void;
+    string(options: Omit<FlagOptions<"string">, "type">): (target: any, propertyKey: string) => void;
+    number(options: Omit<FlagOptions<"number">, "type">): (target: any, propertyKey: string) => void;
+    list(options: Omit<FlagOptions<"list">, "type">): (target: any, propertyKey: string) => void;
+};
+
+/**
+ * Type of Swagger UI to use
+ */
+type SwaggerUIType = "standard" | "rapidoc" | "scalar" | "elements" | "custom";
+type HTMLString = string;
+/**
+ * Custom UI generator function that takes the spec URL and global options and returns HTML
+ */
+type CustomUIGenerator = (specUrl: string, globalOptions: SwaggerGlobalOptions) => HTMLString;
+/**
+ * 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;
+};
+/**
+ * Base options shared across all Swagger UI types
+ */
+type SwaggerGlobalOptionsBase = {
+    /** The path to the swagger documentation, defaults to /docs for the UI and /docs/json for the raw json */
+    path?: string;
+    /** 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> | JSONSchema[];
+};
+/**
+ * Global documentation options for the API (OpenAPI/Swagger style)
+ */
+type SwaggerGlobalOptions = (SwaggerGlobalOptionsBase & {
+    /** Type of Swagger UI to use, one of 'standard', 'redoc', 'rapidoc', 'scalar', or 'elements'. Defaults to 'standard'. */
+    type?: Exclude<SwaggerUIType, "custom">;
+}) | (SwaggerGlobalOptionsBase & {
+    /** Type of Swagger UI to use. When set to 'custom', customUIGenerator is required. */
+    type: "custom";
+    /** Custom UI generator function. Required when type is 'custom'. Must return a string of HTML that uses the given specUrl. */
+    customUIGenerator: CustomUIGenerator;
+});
+/**
+ * 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?: ZodType;
+    /** Request body schema */
+    requestBody?: ZodType;
+    /** Responses for this route */
+    responses?: Record<number, ZodType>;
+    /** Errors for this route */
+    errors?: Record<number, ZodType>;
+    /** 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 AjvInstance = InstanceType<typeof Ajv>;
+type AjvCompileParams = Parameters<AjvInstance["compile"]>;
+
+type SyncOrAsync<T = void> = T | Promise<T>;
+
+interface AsyncLocalStorageContext {
+}
+type AsyncLocalStorageContextSetters<K extends keyof AsyncLocalStorageContext = keyof AsyncLocalStorageContext> = Record<K, (req: Request$1) => SyncOrAsync<AsyncLocalStorageContext[K]>>;
+
+type StaticPluginOptions = {
+    /**
+     * The file system directory path where the assets are located
+     * @example "./tmp/assets" or "public"
+     */
+    source: string;
+    /**
+     * The URL path where the assets will be served
+     * @example "/assets" or "/public"
+     */
+    path: string;
+};
+type FileAllowedMimeType = "text/html" | "text/css" | "application/javascript" | "application/typescript" | "text/jsx" | "text/tsx" | "application/json" | "application/xml" | "application/yaml" | "text/csv" | "text/plain" | "text/markdown" | "image/png" | "image/jpeg" | "image/gif" | "image/svg+xml" | "image/x-icon" | "image/webp" | "image/avif" | "image/bmp" | "image/tiff" | "image/heic" | "image/heif" | "video/mp4" | "video/webm" | "video/x-msvideo" | "video/quicktime" | "video/x-matroska" | "video/x-ms-wmv" | "video/x-flv" | "video/x-m4v" | "video/mpeg" | "video/3gpp" | "audio/mpeg" | "audio/wav" | "audio/ogg" | "audio/flac" | "audio/aac" | "audio/mp4" | "audio/x-ms-wma" | "audio/opus" | "audio/midi" | "font/woff" | "font/woff2" | "font/ttf" | "font/otf" | "application/vnd.ms-fontobject" | "application/pdf" | "application/msword" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.ms-excel" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/vnd.ms-powerpoint" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/vnd.oasis.opendocument.text" | "application/vnd.oasis.opendocument.spreadsheet" | "application/vnd.oasis.opendocument.presentation" | "application/rtf" | "application/epub+zip" | "application/zip" | "application/x-tar" | "application/gzip" | "application/x-bzip2" | "application/x-xz" | "application/vnd.rar" | "application/x-7z-compressed" | "application/wasm" | "application/manifest+json" | "text/calendar" | "text/vcard" | "application/sql" | "application/x-sh" | "application/x-msdos-program" | "application/x-msdownload" | "application/octet-stream" | "application/x-iso9660-image" | "application/x-apple-diskimage" | "application/vnd.android.package-archive" | "application/java-archive" | "application/x-shockwave-flash";
+
+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 each file.
+     * Supports formats like "5mb", "100kb".
+     * Example: "10mb", "500kb"
+     * Default: 1mb
+     */
+    maxFileSize?: `${number}mb` | `${number}kb`;
+    /**
+     * The maximum number of files allowed in a single request.
+     */
+    maxFiles?: number;
+    /**
+     * Allowed MIME types for uploaded files.
+     * If specified, only files with these MIME types will be accepted.
+     * Example: ['image/jpeg', 'image/png', 'application/pdf']
+     */
+    allowedMimeTypes?: (FileAllowedMimeType | (string & {}))[];
+};
+
+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<Params extends Record<string, string> = any> extends NativeRequest {
+    static fromRequest(request: Request$1 | NativeRequest): Request$1;
+    private static compileAndValidate;
+    /**
+     * Enrich native request with validation methods.
+     */
+    static enrichRequest(request: Request$1): Request$1;
+    /**
+     * The context of the request. Can be augmented extending AsyncLocalStorageContext interface
+     * @asyncLocalStorage middleware is required
+     * @example
+     * ```ts
+     * declare module "balda" {
+     *   interface AsyncLocalStorageContext {
+     *     userId: string;
+     *   }
+     * }
+     * ```
+     */
+    ctx: AsyncLocalStorageContext;
+    /**
+     * The file of the request.
+     * @fileParser middleware is required
+     */
+    file: (fieldName: string) => FormFile | null;
+    /**
+     * The cookies of the request.
+     * @cookie middleware is required
+     */
+    cookies: Record<string, string>;
+    /**
+     * The cookie of the request.
+     * @cookie middleware is required
+     */
+    cookie: (name: string) => string | undefined;
+    /**
+     * tells if the request has timed out.
+     * @timeout middleware is required
+     */
+    timeout?: boolean;
+    /**
+     * The session of the request. Uses cookies to send the session id
+     * @cookie middleware is required
+     * @session middleware is required
+     */
+    session?: Record<string, any>;
+    /**
+     * The session of the request. Uses cookies to send the session id
+     * @cookie middleware is required
+     * @session middleware is required
+     */
+    saveSession: () => Promise<void>;
+    /**
+     * The session of the request.
+     * @cookie middleware is required
+     * @session middleware is required
+     */
+    destroySession: () => Promise<void>;
+    /**
+     * 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. Can be typed with a generic in the Request object
+     * @example
+     * ```ts
+     * Request<{ id: string }>
+     */
+    params: Params;
+    /**
+     * 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;
+    set id(value: string);
+    /**
+     * The parsed body of the request
+     */
+    body: any;
+    /**
+     * The validated body of the request.
+     * @param inputSchema - The schema to validate the body against (Zod schema or JSON Schema).
+     * @param safe - If true, the function will return the original body if the validation fails instead of throwing an error.
+     */
+    validate(inputSchema: ZodAny | AjvCompileParams[0], safe?: boolean): any;
+    /**
+     * Validates the query string of the request.
+     * @param inputSchema - The schema to validate the query against (Zod schema or JSON Schema).
+     * @param safe - If true, the function will return undefined if the validation fails instead of throwing an error.
+     */
+    validateQuery(inputSchema: ZodAny | AjvCompileParams[0], safe?: boolean): any;
+    /**
+     * Validates the body and query string of the request.
+     * @param inputSchema - The schema to validate against (Zod schema or JSON Schema).
+     * @param safe - If true, the function will return undefined if the validation fails instead of throwing an error.
+     */
+    validateAll(inputSchema: ZodAny | AjvCompileParams[0], safe?: boolean): any;
+}
+
+/**
+ * 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)
+     * @default true
+     *
+     * ⚠️ Should be `true` in production to prevent transmission over HTTP
+     */
+    secure?: boolean;
+    /**
+     * Whether the cookie is HTTP only (prevents JavaScript access)
+     * @default true
+     *
+     * ✅ Recommended: `true` to prevent XSS attacks
+     */
+    httpOnly?: boolean;
+    /**
+     * SameSite attribute for the cookie
+     *
+     * - "Strict": Most secure, cookie not sent on cross-site requests
+     * - "Lax": Balanced, cookie sent on top-level navigation
+     * - "None": Least secure, requires secure=true
+     *
+     * ✅ Recommended: "Strict" for auth cookies
+     */
+    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$1 {
+    /**
+     * The node http response object available only on the node runtime, useful for direct response manipulation
+     * @warning undefined on other runtimes since they already use Web API Response object
+     */
+    nodeResponse: ServerResponse;
+    /**
+     * 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(htmlString: 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 | Buffer): void;
+    /**
+     * Send a response with the given file content, status defaults to 200
+     * @param options only affects node and bun environment
+     */
+    file(pathToFile: string, options?: {
+        encoding?: string;
+        flag?: 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, cookie middleware must be registered in order to use this function
+     */
+    cookie?(_name: string, _value: string, _options?: CookieOptions): void;
+    /**
+     * Clear a cookie for the response, cookie middleware must be registered in order to use this function
+     */
+    clearCookie?(_name: string, _options?: CookieOptions): void;
+    /**
+     * Stream a response using an async generator or ReadableStream
+     * Sets appropriate headers for Server-Sent Events by default
+     */
+    stream(source: AsyncGenerator<any> | Generator<any> | ReadableStream, options?: {
+        customHeaders?: Record<string, string>;
+    }): void;
+    /**
+     * Get the body of the response
+     */
+    getBody(): any;
+}
+
+type DelHandler = (req: Request$1, res: Response$1, ...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$1, ...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$1, ...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$1, ...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$1, ...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>;
+
+type GraphQLSchemaInput = Parameters<typeof createSchema>[0];
+type GraphQLTypeDef = GraphQLSchemaInput["typeDefs"];
+type GraphQLResolvers = GraphQLSchemaInput["resolvers"];
+interface GraphQLContext {
+}
+type GraphQLResolverFunction<TContext = GraphQLContext> = (parent: unknown, args: Record<string, unknown>, context: TContext, info: unknown) => unknown | Promise<unknown>;
+type GraphQLResolverMap<TContext = GraphQLContext> = Record<string, GraphQLResolverFunction<TContext> | Record<string, unknown>>;
+type GraphQLOptions = {
+    schema?: GraphQLSchemaInput;
+    yogaOptions?: Parameters<typeof createYoga>[0];
+};
+type GraphQLResolverType = "Query" | "Mutation" | "Subscription";
+
+declare class GraphQL {
+    private schemaOptions;
+    private yogaOptions;
+    isEnabled: boolean;
+    constructor(options?: GraphQLOptions);
+    getSchema(createSchemaFn: typeof createSchema): GraphQLSchema;
+    getYogaOptions(): Parameters<typeof createYoga>[0];
+    /**
+     * Add a type definition to the schema
+     */
+    addTypeDef(typeDef: GraphQLTypeDef): void;
+    /**
+     * Add a resolver to the schema
+     * @param type - The resolver type (Query, Mutation, Subscription, or a custom type name)
+     * @param resolvers - An object mapping field names to resolver functions, or a full resolver object
+     */
+    addResolver(type: GraphQLResolverType, resolvers: GraphQLResolverMap): void;
+    addResolver(resolver: GraphQLResolvers): void;
+    addResolver(type: string, resolvers: GraphQLResolverMap): void;
+    private initializeConfiguration;
+    private createDisabledConfiguration;
+    private createEnabledConfiguration;
+    private resolveSchemaOptions;
+    private resolveYogaOptions;
+    private addResolverByType;
+    private ensureResolversInitialized;
+    private mergeResolverIntoObject;
+    private addFullResolver;
+    private addResolverArray;
+    private addResolverObject;
+    private addTypeDefArray;
+    private ensureTypeDefsArray;
+}
+
+declare class MockResponse<T = any> {
+    private readonly response;
+    constructor(response: Response$1);
+    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$1) => 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;
+}
+
+/**
+ * Singleton that handles the routing of requests to the appropriate handler(s).
+ */
+declare class Router {
+    private trees;
+    private routes;
+    private middlewares;
+    private basePath;
+    /**
+     * Create a new router with an optional base path and default middlewares.
+     * Base path is normalized so it never produces duplicate slashes and never ends with a trailing slash (except root).
+     */
+    constructor(basePath?: string, middlewares?: ServerRouteMiddleware[]);
+    /** Returns a shallow copy of all registered routes. */
+    getRoutes(): Route[];
+    /**
+     * Add or update a route
+     * @internal
+     */
+    addOrUpdate(method: HttpMethod, path: string, middleware: ServerRouteMiddleware[], handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    /**
+     * Find the matching route for the given HTTP method and path.
+     * Returns the resolved middleware chain, handler, and extracted params; or null if not found.
+     */
+    find(method: string, rawPath: string): {
+        middleware: ServerRouteMiddleware[];
+        handler: ServerRouteHandler;
+        params: Params;
+    } | null;
+    /**
+     * Register a GET route under this router's base path.
+     */
+    get(path: string, handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    get(path: string, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    /**
+     * Register a POST route under this router's base path.
+     */
+    post(path: string, handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    post(path: string, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    /**
+     * Register a PATCH route under this router's base path.
+     */
+    patch(path: string, handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    patch(path: string, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    /**
+     * Register a PUT route under this router's base path.
+     */
+    put(path: string, handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    put(path: string, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    /**
+     * Register a DELETE route under this router's base path.
+     */
+    delete(path: string, handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    delete(path: string, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    /**
+     * Register an OPTIONS route under this router's base path.
+     */
+    options(path: string, handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    options(path: string, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    /**
+     * Register an HEAD route under this router's base path.
+     */
+    head(path: string, handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    head(path: string, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    /**
+     * Create a grouped router that shares a base path and middlewares.
+     * The callback receives a child router where routes are defined; routes
+     * are then merged back into the parent with the composed base path and middlewares.
+     */
+    group(path: string, middleware: ServerRouteMiddleware[] | ServerRouteMiddleware, cb: (router: Router) => void): void;
+    group(path: string, cb: (router: Router) => void): void;
+    /**
+     * Apply global middlewares to all routes
+     * @param middlewares - The middlewares to apply
+     * @internal
+     */
+    applyGlobalMiddlewaresToAllRoutes(middlewares: ServerRouteMiddleware[]): void;
+    private normalizeBasePath;
+    private joinPath;
+}
+
+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" | "addOrUpdate">;
+
+/**
+ * The server class that is used to create and manage the server
+ */
+declare class Server<H extends NodeHttpClient = NodeHttpClient> implements ServerInterface {
+    isListening: boolean;
+    isProduction: boolean;
+    graphql: GraphQL;
+    readonly router: ClientRouter;
+    private wasInitialized;
+    private serverConnector;
+    private globalMiddlewares;
+    private serverOptions;
+    private controllerImportBlacklistedPaths;
+    private notFoundHandler?;
+    private readonly nativeEnv;
+    private httpsOptions?;
+    /**
+     * 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, if not provided, it will use the PORT environment variable, if not provided, it will default to 80
+     * @param options.host - The hostname to listen on, if not provided, it will use the HOST environment variable, if not provided, it will default 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<H>);
+    get url(): string;
+    get port(): number;
+    get host(): string;
+    get routes(): Route[];
+    hash(data: string): Promise<string>;
+    compareHash(hash: string, data: string): Promise<boolean>;
+    getEnvironment(): Record<string, string>;
+    tmpDir(...append: string[]): string;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+        mode?: number | string;
+    }): Promise<void>;
+    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;
+    options(path: string, handler: ServerRouteHandler): void;
+    options(path: string, options: StandardMethodOptions, handler: ServerRouteHandler): void;
+    head(path: string, handler: ServerRouteHandler): void;
+    head(path: string, options: StandardMethodOptions, handler: ServerRouteHandler): void;
+    group(path: string, middleware: ServerRouteMiddleware[] | ServerRouteMiddleware, cb: (router: ClientRouter) => void): void;
+    group(path: string, cb: (router: ClientRouter) => void): void;
+    getNodeServer(): RuntimeServerMap<"node", H>;
+    getBunServer(): RuntimeServerMap<"bun">;
+    getDenoServer(): RuntimeServerMap<"deno">;
+    embed(key: string, value: any): void;
+    exit(code?: number): void;
+    on(event: SignalEvent, cb: () => SyncOrAsync): void;
+    on(event: string, cb: () => SyncOrAsync): void;
+    once(event: SignalEvent, cb: () => SyncOrAsync): void;
+    once(event: string, cb: () => SyncOrAsync): void;
+    use(...middlewares: ServerRouteMiddleware[]): void;
+    useExpress(pathOrMiddleware: string | RequestHandler | Router$1, maybeMiddleware?: RequestHandler | Router$1): void;
+    expressMiddleware(middleware: RequestHandler): ServerRouteMiddleware;
+    mountExpressRouter(basePath: string, expressRouter: Router$1): void;
+    setErrorHandler(errorHandler?: ServerErrorHandler): void;
+    /**
+     * Sets a custom handler for 404 Not Found responses.
+     * If not set, the default RouteNotFoundError will be used.
+     *
+     * @param notFoundHandler - Optional handler to customize 404 responses
+     * @example
+     * server.setNotFoundHandler((req, res) => {
+     *   res.status(404).json({ error: "Custom not found message" });
+     * });
+     */
+    setNotFoundHandler(notFoundHandler?: ServerRouteHandler): 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
+     * @param options - The options for the mock server
+     * @param options.controllerPatterns - Custom controller patterns to import if the mock server must not be initialized with the same controller patterns as the server
+     */
+    getMockServer(options?: Pick<ServerOptions, "controllerPatterns">): 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;
+    /**
+     * Handles not found routes by delegating to custom handler or default error response
+     * Checks if the path exists for other methods and returns 405 if so
+     * @internal
+     */
+    private handleNotFound;
+    /**
+     * Registers a not found route for all routes that are not defined
+     * @internal
+     */
+    private registerNotFoundRoutes;
+}
+
+/**
+ * Allows to mock server requests without needing to start the server, useful for testing purposes
+ */
+declare class MockServer {
+    readonly server: Server<NodeHttpClient>;
+    constructor(server: Server<NodeHttpClient>);
+    /**
+     * 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 = any>(method: HttpMethod, path: string, options?: MockServerOptions): Promise<MockResponse<T>>;
+    get<T = any>(path: string, options?: Omit<MockServerOptions, "body" | "formData" | "urlencoded">): Promise<MockResponse<T>>;
+    post<T = any>(path: string, options?: MockServerOptions): Promise<MockResponse<T>>;
+    put<T = any>(path: string, options?: MockServerOptions): Promise<MockResponse<T>>;
+    patch<T = any>(path: string, options?: MockServerOptions): Promise<MockResponse<T>>;
+    delete<T = any>(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;
+}
+
+type CompressionOptions = {
+    /**
+     * Minimum response size in bytes to trigger compression
+     * Default: 1024 (1KB)
+     */
+    threshold?: number;
+    /**
+     * Compression level (0-9)
+     * 0 = no compression, 9 = maximum compression
+     * Default: 6
+     */
+    level?: number;
+    /**
+     * Content types to compress (regex patterns)
+     * Default: common compressible types (text, json, xml, javascript, etc.)
+     */
+    filter?: RegExp[];
+};
+
+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.
+     *
+     * ⚠️ WARNING: The default value '*' allows ALL origins, which is insecure for production.
+     *
+     * For production, explicitly set allowed origins:
+     * - Single origin: 'https://example.com'
+     * - Multiple origins: ['https://example.com', 'https://app.example.com']
+     * - Pattern matching: /^https:\/\/.*\.example\.com$/
+     *
+     * Defaults to '*' (allows all origins) - only suitable for development/public APIs.
+     */
+    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;
+};
+
+type ExpressHandler = RequestHandler;
+type ExpressRouter = IRouter;
+interface ExpressAdapterOptions {
+    basePath?: string;
+}
+
+/**
+ * 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;
+}
+
+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: 100kb
+     */
+    sizeLimit?: `${number}mb` | `${number}kb`;
+    /**
+     * 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";
+
+type LoggerOptions = Parameters<typeof pino$1>[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 MethodOverrideOptions = {
+    /**
+     * HTTP methods that can be overridden
+     * Default: ['POST']
+     */
+    methods?: string[];
+    /**
+     * Header name to read the override method from
+     * Default: 'X-HTTP-Method-Override'
+     */
+    header?: string;
+};
+
+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$1 = MemoryStorageStrategy | CustomStorageStrategy;
+/**
+ * Rate limiter options
+ */
+type RateLimiterKeyOptions = IpRateLimiterOptions | CustomRateLimiterOptions;
+
+type SessionStore = {
+    get: (sid: string) => Promise<Record<string, any> | undefined>;
+    set: (sid: string, value: Record<string, any>, ttlSeconds?: number) => Promise<void>;
+    destroy: (sid: string) => Promise<void>;
+};
+type SessionOptions = {
+    /** Cookie name used for session id */
+    name?: string;
+    /** Secret used to sign session id (optional, for future) */
+    secret?: string;
+    /** TTL seconds for session */
+    ttl?: number;
+    /** Custom store, default is in-memory */
+    store?: SessionStore;
+    /** Whether to set HttpOnly secure flags */
+    cookie?: {
+        path?: string;
+        httpOnly?: boolean;
+        secure?: boolean;
+        sameSite?: "Strict" | "Lax" | "None";
+        domain?: string;
+    };
+};
+
+/**
+ * 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 TimeoutOptions = {
+    /** Timeout in milliseconds */
+    ms: number;
+};
+
+type TrustProxyOptions = {
+    /** Enable using X-Forwarded-* headers to determine client IP */
+    trust?: boolean;
+    /** Header name to read the client IP chain from */
+    header?: string;
+    /** Select which IP from the chain to use: 'first' (client) or 'last' (closest proxy) */
+    hop?: "first" | "last";
+};
+
+/**
+ * Options for URL-encoded middleware
+ */
+type UrlEncodedOptions = {
+    /**
+     * The maximum size of the URL-encoded body.
+     * Supports formats like "5mb", "100kb".
+     * Defaults to "1mb".
+     */
+    limit?: `${number}mb` | `${number}kb`;
+    /**
+     * 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;
+};
+
+/**
+ * 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 = () => SyncOrAsync;
+
+type ServerPlugin = {
+    cors?: CorsOptions;
+    json?: JsonOptions;
+    static?: StaticPluginOptions;
+    fileParser?: FilePluginOptions;
+    helmet?: HelmetOptions;
+    cookie?: CookieMiddlewareOptions;
+    log?: LogOptions;
+    urlencoded?: UrlEncodedOptions;
+    rateLimiter?: {
+        keyOptions?: RateLimiterKeyOptions;
+        storageOptions?: StorageOptions$1;
+    };
+    trustProxy?: TrustProxyOptions;
+    timeout?: TimeoutOptions;
+    session?: SessionOptions;
+    methodOverride?: MethodOverrideOptions;
+    compression?: CompressionOptions;
+    asyncLocalStorage?: AsyncLocalStorageContextSetters;
+};
+type NodeHttpClient = "http" | "http2" | "https" | "http2-secure";
+type ServerOptions<H extends NodeHttpClient = NodeHttpClient> = {
+    /** Specific node client to use for nodejs, default to `http` */
+    nodeHttpClient?: H;
+    /** The port to listen on, uses the PORT env if present, defaults to 80 */
+    port?: number;
+    /** The hostname to listen on, uses the HOST env if present, defaults to 0.0.0.0 */
+    host?: string;
+    /** Controller patterns to match, defaults to an empty array */
+    controllerPatterns?: string[];
+    /** Basic plugins to apply to all requests, plugins are applied in order based on where they are defined in the `plugins` object, 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;
+    /** Whether to use the body parser plugin, by default it is true, it is really recommended to use it */
+    useBodyParser?: boolean;
+    /**
+     * 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;
+    /**
+     * The graphql options to apply to the server, by default graphql plugin is not enabled, you can pass a boolean to enable or disable the plugin or you can pass an object to apply custom options to the plugin (when options are provided the plugin is always enabled)
+     * @example
+     * ```ts
+     * const server = new Server({
+     *   graphql: true,
+     * });
+     * ```
+     * @example
+     * ```ts
+     * const server = new Server({
+     *   graphql: {
+     *     schema: createSchema({ typeDefs: `type Query { hello: String }`, resolvers: { Query: { hello: () => 'Hello World' } } }),
+     *   },
+     * });
+     * ```
+     */
+    graphql?: GraphQLOptions;
+    /**
+     * The ajv instance to use for the server for validation, by default a global instance is used, you can pass a custom instance to use for the server
+     * @example
+     * ```ts
+     * const server = new Server({
+     *   ajvInstance: new Ajv(),
+     * });
+     * ```
+     */
+    ajvInstance?: Ajv;
+} & (H extends "https" | "http2-secure" ? HttpsOptions<H> : {});
+/** Internal resolved server options with all required properties */
+type ResolvedServerOptions = {
+    nodeHttpClient: NodeHttpClient;
+    port: number;
+    host: string;
+    controllerPatterns: string[];
+    plugins: ServerPlugin;
+    tapOptions: ServerTapOptions;
+    useBodyParser: boolean;
+    swagger: Parameters<typeof swagger>[0] | boolean;
+    graphql?: GraphQLOptions;
+};
+type ServerErrorHandler = (req: Request$1, res: Response$1, next: NextFunction, error: Error) => SyncOrAsync;
+interface ServerInterface {
+    /**
+     * Whether the server is in production mode NODE_ENV is set to "production"
+     */
+    isProduction: boolean;
+    /**
+     * 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;
+    /**
+     * Main singleton router instance of the server
+     */
+    router: ClientRouter;
+    /**
+     * Hash the given data using the native hash function of the current runtime
+     * @param data - The data to hash
+     * @returns The hashed data
+     */
+    hash: (data: string) => Promise<string>;
+    /**
+     * Compare the given data with the given hash using the native hash function of the current runtime
+     * @param hash - The hash to compare the data with
+     * @param data - The data to compare with the hash
+     * @returns Whether the data matches the hash
+     */
+    compareHash: (hash: string, data: string) => Promise<boolean>;
+    /**
+     * Get the environment variables of the server using the native environment variables of the current runtime
+     */
+    getEnvironment: () => Record<string, string>;
+    /**
+     * 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;
+    /**
+     * Create a new directory
+     * @param path - The path to the directory
+     * @param options - The options to create the directory
+     * @param options.recursive - Whether to create the directory recursively
+     * @param options.mode - The mode of the directory
+     */
+    mkdir: (path: string, options?: {
+        recursive?: boolean;
+        mode?: number | string;
+    }) => Promise<void>;
+    /**
+     * Mount an Express middleware or router at a specific path for compatibility with Express-based libraries like AdminJS
+     * @param pathOrMiddleware - The path to mount at, or the Express middleware/router if mounting at root
+     * @param maybeMiddleware - The Express middleware or router when path is provided
+     */
+    useExpress: (pathOrMiddleware: string | RequestHandler | ExpressRouter, maybeMiddleware?: RequestHandler | ExpressRouter) => void;
+    /**
+     * Convert an Express middleware to a Balda-compatible middleware
+     * @param middleware - The Express middleware to convert
+     * @returns A Balda-compatible middleware
+     */
+    expressMiddleware: (middleware: RequestHandler) => ServerRouteMiddleware;
+    /**
+     * Mount an Express router at a specific base path
+     * @param basePath - The base path to mount the router at
+     * @param expressRouter - The Express router to mount
+     */
+    mountExpressRouter: (basePath: string, expressRouter: ExpressRouter) => void;
+    /**
+     * Shorthand for the server.router.get method
+     */
+    get: (...args: any[]) => void;
+    /**
+     * Shorthand for the server.router.post method
+     */
+    post: (...args: any[]) => void;
+    /**
+     * Shorthand for the server.router.put method
+     */
+    put: (...args: any[]) => void;
+    /**
+     * Shorthand for the server.router.patch method
+     */
+    patch: (...args: any[]) => void;
+    /**
+     * Shorthand for the server.router.delete method
+     */
+    delete: (...args: any[]) => void;
+    /**
+     * Shorthand for the server.router.options method
+     */
+    options: (...args: any[]) => void;
+    /**
+     * Shorthand for the server.router.head method
+     */
+    head: (...args: any[]) => void;
+    /**
+     * Shorthand for the server.router.group method
+     */
+    group: (...args: any[]) => void;
+    /**
+     * Get the node server instance, you must be using node runtime to use this method based on the nodeHttpClient option passed to the server constructor (defaults to http)
+     * @throws if the runtime is not node
+     */
+    getNodeServer: () => RuntimeServerMap<"node", NodeHttpClient>;
+    /**
+     * Get the bun server instance, you must be using bun runtime to use this method
+     * @throws if the runtime is not bun
+     */
+    getBunServer: () => RuntimeServerMap<"bun">;
+    /**
+     * Get the deno server instance, you must be using deno runtime to use this method
+     * @throws if the runtime is not deno
+     */
+    getDenoServer: () => RuntimeServerMap<"deno">;
+    /**
+     * 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 Server {
+     *     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: () => SyncOrAsync) => 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
+     */
+    once: (event: SignalEvent, cb: () => SyncOrAsync) => 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;
+    /**
+     * Set the not found handler for the server
+     * @param notFoundHandler - The not found handler to be applied to all routes
+     */
+    setNotFoundHandler: (notFoundHandler?: ServerRouteHandler) => 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;
+}
+type StandardMethodOptions = {
+    middlewares?: ServerRouteMiddleware[] | ServerRouteMiddleware;
+    swagger?: SwaggerRouteOptions;
+};
+type SignalEvent = Deno.Signal | NodeJS.Signals;
+
+type RunTimeType = "bun" | "node" | "deno";
+
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD";
+type NodeServer = Server$2 | Server$1 | Http2Server;
+type RuntimeServer = NodeServer | ReturnType<typeof Bun.serve> | ReturnType<typeof Deno.serve>;
+type RuntimeServerMap<T extends RunTimeType, H extends NodeHttpClient = "http"> = T extends "node" ? H extends "https" ? Server$1 : H extends "http2" | "http2-secure" ? Http2Server : Server$2 : T extends "bun" ? ReturnType<typeof Bun.serve> : T extends "deno" ? ReturnType<typeof Deno.serve> : never;
+type HttpsOptions<T extends NodeHttpClient> = T extends "https" | "http2-secure" ? {
+    /** HTTPS/TLS options, required when nodeHttpClient is 'https' or 'http2-secure' */
+    httpsOptions: ServerOptions$1;
+} : never;
+type ServerConnectInput<H extends NodeHttpClient = NodeHttpClient> = {
+    /** The port to listen on, defaults to 80 */
+    port: number;
+    /** The hostname to listen on, defaults to 0.0.0.0 */
+    host: string;
+    /** The server routes with their corresponding handler */
+    routes: ServerRoute[];
+    /** The options for the server tap function */
+    tapOptions?: ServerTapOptions;
+    /** The runtime to use for the server */
+    runtime: RunTimeType;
+    /** Specific node client to use */
+    nodeHttpClient: H;
+    /** The graphql options to apply to the server */
+    graphql?: GraphQL;
+} & (H extends "https" ? HttpsOptions<H> : {});
+type ServerRouteMiddleware = (req: Request$1, res: Response$1, next: NextFunction) => SyncOrAsync;
+type ServerRouteHandler = (req: Request$1, res: Response$1) => SyncOrAsync;
+interface ServerRoute {
+    /** The path for the route */
+    path: string;
+    /** The HTTP method for the route */
+    method: HttpMethod;
+    /** The handler to call when the route is requested */
+    handler: ServerRouteHandler;
+    /** The middleware chain to call before the handler */
+    middlewares?: ServerRouteMiddleware[];
+}
+type ServerListenCallback = ({ port, host, url, }: {
+    port: number;
+    host: string;
+    url: string;
+}) => SyncOrAsync;
+/**
+ * Custom bun fetch call to be used as an hook inside Bun.serve method
+ */
+type CustomBunFetch = (req: Request$1, server: Bun.Server<any>) => SyncOrAsync;
+/**
+ * Custom deno fetch call to be used as an hook inside Deno.serve method
+ */
+type CustomDenoFetch = (...options: Parameters<Parameters<typeof Deno.serve>[0]["handler"]>) => SyncOrAsync<Response | 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;
+    websocket?: {
+        open?: (ws: WebSocket) => void;
+        message?: (ws: WebSocket, message: string) => void;
+        close?: (ws: WebSocket) => void;
+    };
+} : never;
+type BunTapOptions = ServerTapOptionsBuilder<"bun">;
+type NodeTapOptions = ServerTapOptionsBuilder<"node">;
+type DenoTapOptions = ServerTapOptionsBuilder<"deno">;
+type ServerTapOptions = {
+    bun?: BunTapOptions;
+    node?: NodeTapOptions;
+    deno?: 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 SerializeOptions {
+    /**
+     * The status code to serialize the response body against (useful only for the documentation does not affect the actual response status)
+     * @default 200
+     */
+    status?: number;
+    /**
+     * Whether to use safe serialization (returns original data if serialization fails instead of throwing)
+     * Advised to only set unsafe if development environment
+     * @default true
+     */
+    safe?: boolean;
+}
+
+declare const serialize: <T extends ZodType | AjvCompileParams[0]>(schema: T, options?: SerializeOptions) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+
+interface CustomValidationError {
+    status?: number;
+    message?: string;
+}
+interface ValidationOptions {
+    /**
+     * The schema to validate the request body against (Zod schema or OpenAPI schema)
+     */
+    body?: ZodType | AjvCompileParams[0];
+    /**
+     * The schema to validate the query parameters against (Zod schema or OpenAPI schema)
+     */
+    query?: ZodType | AjvCompileParams[0];
+    /**
+     * The schema to validate both body and query against (Zod schema or OpenAPI schema)
+     */
+    all?: ZodType | AjvCompileParams[0];
+    /**
+     * 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: ZodType | AjvCompileParams[0], customError?: CustomValidationError): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    body(schema: ZodType | AjvCompileParams[0], customError?: CustomValidationError): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    all(schema: ZodType | AjvCompileParams[0], customError?: CustomValidationError): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+};
+
+/**
+ * Base class for cron jobs with logger instance
+ * @example
+ * export default class MyCron extends BaseCron {
+ *   @cron("* * * * *")
+ *   handle() {
+ *     this.logger.info("Running cron job");
+ *   }
+ * }
+ */
+declare class BaseCron {
+    protected readonly logger: pino.Logger<string, boolean>;
+}
+
+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>;
+}
+declare const setCronGlobalErrorHandler: (globalErrorHandler: (...args: Parameters<(typeof CronService)["globalErrorHandler"]>) => void) => void;
+
+declare class BullMQPubSub implements PubSub<"bullmq"> {
+    private queues;
+    private workers;
+    private bullmqClient;
+    publish<T extends QueueTopicKey>(topic: T, payload: QueueTopic[T], options?: PublishOptions<"bullmq">): Promise<{
+        id: string;
+    }>;
+    subscribe<T extends QueueTopicKey>(topic: T, handler: (payload: QueueTopic[T]) => Promise<void>): Promise<void>;
+    private getQueue;
+    private getBullMQClient;
+}
+
+declare class PGBossPubSub implements PubSub<"pgboss"> {
+    private boss;
+    private createdQueues;
+    publish<T extends QueueTopicKey>(topic: T, payload: QueueTopic[T], options?: PublishOptions<"pgboss">): Promise<{
+        id: string;
+    }>;
+    subscribe<T extends QueueTopicKey>(topic: T, handler: (payload: QueueTopic[T]) => Promise<void>): Promise<void>;
+    private getBoss;
+    private ensureQueue;
+}
+
+declare class SQSPubSub implements PubSub<"sqs"> {
+    private consumers;
+    private client?;
+    private sqsLib;
+    private sqsConsumerLib;
+    publish<T extends QueueTopicKey>(topic: T, payload: QueueTopic[T], options?: PublishOptions<"sqs">): Promise<{
+        id: string;
+    }>;
+    subscribe<T extends QueueTopicKey>(topic: T, handler: (payload: QueueTopic[T]) => Promise<void>): Promise<void>;
+    private getClient;
+    private getSqsLib;
+    private getSqsConsumerLib;
+    private resolveQueueUrl;
+}
+
+type BullMQAddTaskOptions = Parameters<Queue["add"]>[2];
+type PGBossSendOptions = Parameters<PgBoss["send"]>[2];
+type SQSPublishOptions = Parameters<SQSClient["send"]>[0];
+type PublishOptions<T extends QueueProviderKey> = T extends "bullmq" ? BullMQAddTaskOptions : T extends "sqs" ? SQSPublishOptions : T extends "pgboss" ? PGBossSendOptions : never;
+interface QueueTopic {
+}
+type QueueTopicKey = keyof QueueTopic;
+interface PubSub<P extends QueueProviderKey = any> {
+    publish: <T extends QueueTopicKey>(topic: T, payload: QueueTopic[T], options: PublishOptions<P>) => Promise<{
+        id: string;
+    }>;
+    subscribe: <T extends QueueTopicKey>(topic: T, handler: (payload: QueueTopic[T]) => Promise<void>) => Promise<void>;
+}
+interface QueueProvider {
+    bullmq: BullMQPubSub;
+    sqs: SQSPubSub;
+    pgboss: PGBossPubSub;
+}
+type QueueProviderKey = keyof QueueProvider;
+
+/**
+ * Decorator to register a queue handler
+ * @param provider - The provider to use
+ * @param topic - The topic to subscribe to
+ * @returns A function to decorate the handler
+ */
+declare const queue: {
+    <P extends QueueProviderKey, T extends QueueTopicKey>(provider: P, topic: T): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    bullmq<T extends QueueTopicKey>(topic: T): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    sqs<T extends QueueTopicKey>(topic: T): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    pgboss<T extends QueueTopicKey>(topic: T): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+};
+
+type QueueRegistration = {
+    name: string;
+    topic: QueueTopicKey;
+    handler: (payload: any) => Promise<void>;
+    provider: QueueProviderKey;
+};
+declare class QueueService {
+    static scheduledSubscribers: QueueRegistration[];
+    static register(name: string, topic: QueueRegistration["topic"], handler: QueueRegistration["handler"], options?: {
+        provider?: QueueProviderKey;
+    }): void;
+    static run(): Promise<void>;
+    static massiveImportQueues(queueHandlerPatterns: string[]): Promise<void>;
+}
+
+/**
+ * Base class for MQTT handlers with logger instance
+ * @example
+ * declare module "balda" {
+ *   export interface BaseMqtt {
+ *     logger: Logger;
+ *   }
+ * }
+ *
+ * export default class TemperatureHandler extends BaseMqtt {
+ *   @mqtt("home/temperature")
+ *   handle(topic: string, message: Buffer) {
+ *     this.logger.info("Received temperature:", message.toString());
+ *   }
+ * }
+ */
+declare class BaseMqtt {
+    protected readonly logger: pino.Logger<string, boolean>;
+}
+
+interface MqttTopics {
+}
+type MqttHandler<T extends MqttTopics> = (topic: keyof T, message: T[keyof T]) => void | Promise<void>;
+type MqttSubscription<T extends MqttTopics> = {
+    name: string;
+    topic: keyof T;
+    handler: MqttHandler<T>;
+    options?: IClientSubscribeOptions;
+};
+type MqttSubscribeOptions = IClientSubscribeOptions;
+type MqttPublishOptions = IClientPublishOptions;
+type MqttConnectionOptions = IClientOptions;
+
+declare class MqttService {
+    static subscriptions: MqttSubscription<MqttTopics>[];
+    static client: MqttClient | null;
+    static connectionOptions: MqttConnectionOptions;
+    /**
+     * @description Register an MQTT subscription handler.
+     * @internal
+     * @example
+     * MqttService.register('test', 'home/temperature', (topic, message) => {
+     *   console.log('Received message:', message.toString());
+     * }, { qos: 1 });
+     */
+    static register<T extends MqttTopics>(name: string, topic: keyof T, handler: MqttHandler<T>, options?: IClientSubscribeOptions): void;
+    /**
+     * @description Connect to the MQTT broker and subscribe to all registered topics.
+     */
+    static connect(connectionOptions?: MqttConnectionOptions): Promise<void>;
+    /**
+     * @description Subscribe to all registered topics.
+     * @internal
+     */
+    private static subscribeToTopics;
+    /**
+     * @description Handle incoming MQTT messages.
+     * @internal
+     */
+    private static handleMessage;
+    /**
+     * @description Main error handler for MQTT operations. You can write your own error handler by overriding this static method for example with sentry.
+     */
+    static globalErrorHandler(error: Error): SyncOrAsync<void>;
+    static setOnDisconnectHandler(handler: () => void): void;
+    static setOnReconnectHandler(handler: () => void): void;
+    /**
+     * @description Import all MQTT handlers from specified patterns
+     */
+    static massiveImportMqttHandlers(mqttHandlerPatterns: string[]): Promise<void>;
+    /**
+     * Create a decorator to subscribe to an MQTT topic
+     * Messages are automatically parsed: Buffer -> JSON object (if valid) -> string
+     * Supports MQTT wildcards: + (single level) and # (multi level)
+     *
+     * Handler signature can be either:
+     * - `handler(message: T)` - just the message (topic omitted)
+     * - `handler(topic: string, message: T)` - include topic for wildcards or logging
+     *
+     * @example
+     * @mqtt.handler('home/temperature', { qos: 1 })
+     * handleTemperature(message: { value: number; unit: string }) {
+     *   console.log('Temperature:', message.value, message.unit);
+     * }
+     *
+     * @example With topic parameter (useful for wildcards)
+     * @mqtt.handler('home/+/temperature', { qos: 1 })
+     * handleRoomTemperature(topic: string, message: string) {
+     *   const room = topic.split('/')[1];
+     *   console.log(`${room} temperature:`, message);
+     * }
+     */
+    subscribe<T extends MqttTopics = MqttTopics>(topic: keyof T, options?: IClientSubscribeOptions): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    /**
+     * @description Publish a message to an MQTT topic
+     * @param topic - The topic to publish to
+     * @param message - The message payload (string, Buffer, or object that will be JSON stringified)
+     * @param options - Publish options (qos, retain, etc.)
+     * @throws BaldaError if the MQTT client is not connected or is not installed as a dependency
+     */
+    publish<T extends MqttTopics>(topic: keyof T, message: T[keyof T], options?: MqttPublishOptions): Promise<void>;
+    /**
+     * @description Disconnect the MQTT client gracefully
+     */
+    static disconnect(): Promise<void>;
+}
+declare const setMqttGlobalErrorHandler: (globalErrorHandler: (...args: Parameters<(typeof MqttService)["globalErrorHandler"]>) => void) => void;
+/**
+ * Singleton instance for publishing MQTT messages
+ * @example
+ * import { mqtt } from 'balda';
+ *
+ * await mqtt.publish('home/temperature', { value: 23.5, unit: 'C' }, { qos: 1 });
+ */
+declare const mqtt: MqttService;
+
+/**
+ * Base class for queue handlers with logger instance
+ * @example
+ * export default class MyQueue extends BaseQueue {
+ *   @queue("bullmq", "my-topic")
+ *   async handle(payload: MyPayload) {
+ *     this.logger.info({ payload }, "Processing queue message");
+ *   }
+ * }
+ */
+declare class BaseQueue {
+    protected readonly logger: pino.Logger<string, boolean>;
+}
+
+/**
+ * Options for BullMQ configuration
+ * @param options - The options for BullMQ
+ * @param errorHandler - Custom error handler that will be triggered when a job fails, for logging or debug purposes
+ */
+type BullMQConfigurationOptions = ConstructorParameters<typeof Queue>[1] & {
+    errorHandler?: (job: Job, error: Error) => SyncOrAsync;
+};
+declare class BullMQConfiguration {
+    static options: BullMQConfigurationOptions;
+}
+/**
+ * Define globally custom BullMQ configuration
+ * @param options - The BullMQ configuration options
+ */
+declare const defineBullMQConfiguration: (options: BullMQConfigurationOptions) => void;
+
+type CustomQueueConfiguration = PubSub;
+
+type PGBossConfigurationOptions = {
+    connectionString?: string;
+    boss?: unknown;
+    errorHandler?: (error: Error) => SyncOrAsync;
+};
+declare class PGBossConfiguration {
+    static options: PGBossConfigurationOptions;
+}
+declare const definePGBossConfiguration: (options: PGBossConfigurationOptions) => void;
+
+type SQSConfigurationOptions = {
+    client?: SQSClientConfig;
+    consumer?: {
+        batchSize?: number;
+        visibilityTimeout?: number;
+        waitTimeSeconds?: number;
+        queueUrlMap: Record<QueueTopicKey, string>;
+    };
+    errorHandler?: (error: Error) => SyncOrAsync;
+};
+declare class SQSConfiguration {
+    static options: SQSConfigurationOptions;
+}
+declare const defineSQSConfiguration: (options: SQSConfigurationOptions) => void;
+
+/**
+ * Main publisher for balda queue, has shortcuts for base providers, e.g. `publish.bullmq`
+ * @param provider - The provider to use
+ * @param topic - The topic to publish to
+ * @param payload - The payload to publish
+ * @param options - The options to use
+ * @returns The id of the published job
+ */
+declare const publish: {
+    <P extends QueueProviderKey, T extends QueueTopicKey>(provider: P, topic: T, payload: QueueTopic[T], options?: PublishOptions<P>): Promise<{
+        id: string;
+    }>;
+    bullmq<T extends QueueTopicKey>(topic: T, payload: QueueTopic[T], options?: PublishOptions<"bullmq">): Promise<{
+        id: string;
+    }>;
+    sqs<T extends QueueTopicKey>(topic: T, payload: QueueTopic[T], options?: PublishOptions<"sqs">): Promise<{
+        id: string;
+    }>;
+    pgboss<T extends QueueTopicKey>(topic: T, payload: QueueTopic[T], options?: PublishOptions<"pgboss">): Promise<{
+        id: string;
+    }>;
+};
+
+declare class QueueManager {
+    static map: Map<QueueProviderKey, PubSub>;
+    static getProvider<P extends QueueProviderKey>(provider: P): PubSub<P>;
+    static setProvider(provider: QueueProviderKey, pubsub: PubSub<QueueProviderKey>): void;
+}
+
+/**
+ * Main entry point to define the queue configuration, meant to be called only once in the application bootstrap
+ * @bullmq - The BullMQ configuration options
+ * @pgboss - The PGBoss configuration options
+ * @sqs - The SQS configuration options
+ * @string - The custom queue provider name with it's PubSub implementation
+ * @example
+ * defineQueueConfiguration({
+ *   bullmq: {
+ *     connection: {
+ *       host: "127.0.0.1",
+ *       password: "root",
+ *       username: "default",
+ *       db: 0,
+ *     },
+ *   },
+ *   pgboss: {
+ *     connectionString: "postgres://root:root@localhost:5432/database",
+ *   },
+ *   sqs: {
+ *     client: { region: "us-east-1" },
+ *   },
+ *   custom: new CustomPubSub(),
+ * });
+ * @example
+ * defineQueueConfiguration({
+ *   custom: new CustomPubSub(),
+ * });
+ */
+declare const defineQueueConfiguration: (options: {
+    bullmq?: Parameters<typeof defineBullMQConfiguration>[0];
+    pgboss?: Parameters<typeof definePGBossConfiguration>[0];
+    sqs?: Parameters<typeof defineSQSConfiguration>[0];
+} & { [key in Exclude<QueueProviderKey, "bullmq" | "pgboss" | "sqs">]?: CustomQueueConfiguration; }) => void;
+
+/**
+ * The logger instance, can be overridden by the `defineLoggerConfig` function
+ */
+declare let logger: pino__default.Logger<string, boolean>;
+/**
+ * Define the logger config, this will override the logger instance with the given options
+ * @param options - The logger options
+ */
+declare const defineLoggerConfig: (options?: LoggerOptions) => void;
+
+type Argument = string;
+type FlagSchema = Record<string, string | number | boolean | Array<string | number | boolean>>;
+
+type CommandOptions = {
+    /**
+     * If true, the command won't be killed after it's finished. Defaults to false.
+     */
+    keepAlive?: boolean;
+    /**
+     * Category for grouping commands in help output
+     * @example 'generator', 'development', 'production', 'database'
+     */
+    category?: string;
+    /**
+     * Mark command as deprecated with optional replacement
+     * @example { message: 'Use generate-controller instead', replacement: 'generate-controller' }
+     */
+    deprecated?: {
+        message?: string;
+        replacement?: string;
+    };
+    /**
+     * Custom validation function that runs before handle()
+     */
+    validate?: (command: typeof Command) => boolean | Promise<boolean>;
+};
+
+/**
+ * Base class for all cli commands.
+ * @abstract
+ */
+declare abstract class Command {
+    /**
+     * The name of the command.
+     */
+    static commandName: string;
+    /**
+     * package manager that called the command (e.g. npx, yarn, bun etc.)
+     */
+    static calledBy: string;
+    /**
+     * The description of the command.
+     */
+    static description: string;
+    /**
+     * The help text of the command.
+     */
+    static help: string[] | string;
+    /**
+     * The options of the command.
+     */
+    static options: CommandOptions;
+    /**
+     * Static arguments in order to be validated by decorators. Will be fetched in the command instance.
+     */
+    static args: Argument[];
+    /**
+     * Static flags in order to be validated by decorators. Will be fetched in the command instance.
+     */
+    static flags: FlagSchema;
+    static readonly logger: pino.Logger<string, boolean>;
+    /**
+     * Main entry point for the command.
+     */
+    static handle(): Promise<void>;
+    /**
+     * Enhanced help flag handler with rich formatting and command information
+     */
+    static handleHelpFlag(flags: FlagSchema): void;
+    private static readonly generateHelpOutput;
+    static readonly validateContext: (target: any) => void;
+}
+
+declare class BuildCommand extends Command {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    static clearDist: boolean;
+    static entry: string;
+    static output: string;
+    static tsconfig: string;
+    static assets: string;
+    static format: "esm" | "cjs";
+    static packages: "external" | "bundle";
+    static sourcemap: boolean;
+    static handle(): Promise<void>;
+}
+
+declare class GenerateCommand extends Command {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    /**
+     * The path where the command will be generated
+     */
+    static path: string;
+    static name: string;
+    static handle(): Promise<void>;
+    static getCommandTemplate(): string;
+}
+
+declare class GenerateControllerCommand extends Command {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    static controllerName: string;
+    static path: string;
+    static handle(): Promise<void>;
+    static getControllerTemplate(): string;
+}
+
+declare class GenerateCron extends Command {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    static fileName: string;
+    static path: string;
+    static handle(): Promise<void>;
+    static getCronTemplate(): string;
+}
+
+declare class GenerateMiddlewareCommand extends Command {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    static middlewareName: string;
+    static path: string;
+    static handle(): Promise<void>;
+    static getMiddlewareTemplate(): string;
+}
+
+declare class GenerateMqttCommand extends Command {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    static path: string;
+    static topic: string;
+    static handle(): Promise<void>;
+    static getMqttTemplate(isValidLiteral: boolean): string;
+}
+
+declare class GeneratePluginCommand extends Command {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    static pluginName: string;
+    static pluginPath: string;
+    static handle(): Promise<void>;
+    static getPluginTemplate(): string;
+}
+
+declare class GenerateQueueCommand extends Command {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    static queueName: string;
+    static path: string;
+    static provider: string;
+    static handle(): Promise<void>;
+    static getQueueTemplate(isValidLiteral: boolean): string;
+}
+
+declare class InitCommand extends Command {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    static srcPath: string;
+    static typescript: boolean;
+    static mqtt: boolean;
+    static cron: boolean;
+    static devDependencies: string[];
+    static handle(): Promise<void>;
+    static getServerTemplate(): string;
+    static getIndexTemplate(): string;
+    static getMqttConfigTemplate(): string;
+    static getCronConfigTemplate(): string;
+}
+
+declare class InitQueueCommand extends Command {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    static queueType: "bullmq" | "sqs" | "pgboss";
+    static outputPath: string;
+    static queueDependencies: Record<string, string[]>;
+    static handle(): Promise<void>;
+    static getConfigTemplate(): string;
+    static getBullMQTemplate(): string;
+    static getSQSTemplate(): string;
+    static getPGBossTemplate(): string;
+}
+
+declare class ListCommand extends Command {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    static handle(): Promise<void>;
+    private static groupByCategory;
+    private static displayCategorizedCommands;
+}
+
+declare class ServeCommand extends Command {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    static runtime: RunTimeType;
+    static options: CommandOptions;
+    static entry: string;
+    static denoImportMap?: string;
+    static handle(): Promise<void>;
+    private static handleNodeHotReload;
+}
+
+declare class SetupStorageCommand extends Command {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    static storageType: string;
+    static outputPath: string;
+    static handle(): Promise<void>;
+    private static getDependencies;
+    private static checkMissingDependencies;
+    private static createStorageSetup;
+    private static getConfigTemplate;
+}
+
+declare const baseCommands: (typeof BuildCommand | typeof GenerateCommand | typeof GenerateControllerCommand | typeof GenerateCron | typeof GenerateMiddlewareCommand | typeof GenerateMqttCommand | typeof GeneratePluginCommand | typeof GenerateQueueCommand | typeof InitCommand | typeof InitQueueCommand | typeof ListCommand | typeof ServeCommand | typeof SetupStorageCommand)[];
+/**
+ * Singleton that registers all commands and provides a way to execute them.
+ * Commands are loaded from the commands directory, and are expected to have a default export with the command class that extends the base command class.
+ * Commands can be run both as `.js` or `.ts` files. If the file is a ts file `typescript` npm package must be installed.
+ * You can use the `CommandRegistry.setCommandsPattern` method to change the pattern of the commands to load.
+ * @example
+ * // commands/test.ts
+ * export default class TestCommand extends Command {
+ *   static name = "test";
+ *   async handle() {
+ *     console.log("Test command");
+ *   }
+ * }
+ */
+declare class CommandRegistry {
+    private commands;
+    private builtInCommands;
+    static commandsPattern: string;
+    static logger: pino.Logger<string, boolean>;
+    /**
+     * Private constructor to prevent direct instantiation
+     * @internal Not meant to be used outside by the user
+     */
+    private constructor();
+    static getInstance(): CommandRegistry;
+    static setCommandsPattern(pattern: string): void;
+    getCommand(name: string): typeof Command | null;
+    getCommands(): (typeof Command)[];
+    getBuiltInCommands(): (typeof Command)[];
+    getUserDefinedCommands(): (typeof Command)[];
+    isBuiltInCommand(commandName: string): boolean;
+    loadCommands(commandsPattern: string): Promise<void>;
+}
+declare const commandRegistry: CommandRegistry;
+
+declare class NativeHash {
+    private readonly ITERATIONS;
+    private readonly SALT_LENGTH;
+    private readonly KEY_LENGTH;
+    hash(data: string): Promise<string>;
+    compare(hash: string, data: string): Promise<boolean>;
+    private encodeBase64;
+    private decodeBase64;
+}
+declare const hash: NativeHash;
+
+declare const asyncStorage: AsyncLocalStorage<Record<string, any>>;
+/**
+ * Async local storage plugin middleware, used to store data in the request context
+ */
+declare const asyncLocalStorage: (ctxSetters: AsyncLocalStorageContextSetters) => ServerRouteMiddleware;
+
+type LocalStorageProviderOptions = {
+    /**
+     * The directory to store the files
+     */
+    directory: string;
+};
+/**
+ * Local storage provider, stores files in the local filesystem
+ * Note: This provider does not support signed URLs (getDownloadUrl/getUploadUrl)
+ */
+declare class LocalStorageProvider implements StorageInterface {
+    private readonly options;
+    private wasDirectoryEnsured;
+    constructor(options: LocalStorageProviderOptions);
+    getDownloadUrl(_key: string, _expiresInSeconds?: number): Promise<string>;
+    getUploadUrl(_key: string, _expiresInSeconds?: number): Promise<string>;
+    listObjects(prefix?: string): Promise<string[]>;
+    getObject<R extends ReturnType$1 = "raw">(key: string, returnType?: R): Promise<ReturnTypeMap<R>>;
+    putObject<T = Uint8Array>(key: string, value: T, _contentType?: string): Promise<void>;
+    deleteObject(key: string): Promise<void>;
+    private listFilesRecursively;
+    private readDirectory;
+    private ensureDirectoryExists;
+}
+
+type S3ClientConfig = ConstructorParameters<typeof S3Client>[0];
+type S3StorageProviderOptions = {
+    s3ClientConfig: S3ClientConfig & {
+        bucketName: string;
+    };
+    /**
+     * The cloudfront options (optional), allows to get the cloudfront signed url for an object, enables the `getDownloadUrl` method that throws an error if not configured
+     */
+    cloudfrontOptions?: {
+        /**
+         * The CloudFront distribution domain name (e.g., 'd1234567890.cloudfront.net')
+         */
+        domainName: string;
+        /**
+         * The CloudFront key pair ID
+         */
+        keyPairId: string;
+        /**
+         * The private key in PEM format for signing URLs
+         */
+        privateKey: string;
+    };
+};
+declare class S3StorageProvider implements StorageInterface {
+    private s3Lib;
+    private s3PresignerLib;
+    private cloudfrontSignerLib;
+    private s3Client;
+    readonly options: S3StorageProviderOptions;
+    constructor(options: S3StorageProviderOptions);
+    getDownloadUrl(key: string, expiresInSeconds?: number): Promise<string>;
+    getUploadUrl(key: string, expiresInSeconds?: number): Promise<string>;
+    listObjects(prefix?: string): Promise<string[]>;
+    getObject<R extends ReturnType$1 = "raw">(key: string, returnType?: R): Promise<ReturnTypeMap<R>>;
+    putObject<T = Uint8Array>(key: string, value: T, contentType?: string): Promise<void>;
+    deleteObject(key: string): Promise<void>;
+    private ensureClient;
+}
+
+type ReturnType$1 = "raw" | "text" | "stream";
+type ReturnTypeMap<T extends ReturnType$1> = T extends "raw" ? Uint8Array : T extends "text" ? string : T extends "stream" ? ReadableStream : never;
+/**
+ * High level storage interface, provides a unified way to interact with different storage providers
+ */
+interface StorageInterface {
+    /**
+     * Get the download signed url of the object
+     * @param key - The key of the object
+     * @returns The download signed url of the object
+     */
+    getDownloadUrl: (key: string, expiresInSeconds?: number) => Promise<string>;
+    /**
+     * Get the upload signed url of the object
+     * @param key - The key of the object
+     * @returns The upload signed url of the object
+     */
+    getUploadUrl: (key: string, expiresInSeconds?: number) => Promise<string>;
+    /**
+     * List the objects from the storage
+     * @param prefix - The prefix of the objects
+     * @returns The objects from the storage
+     */
+    listObjects: (prefix?: string) => Promise<string[]>;
+    /**
+     * Get the object from the storage
+     * @param key - The key of the object
+     * @throws If no file is found for the given key
+     * @returns The object from the storage
+     */
+    getObject: <R extends ReturnType$1 = "raw">(key: string, returnType: R) => Promise<ReturnTypeMap<R>>;
+    /**
+     * Put the object into the storage
+     * @param key - The key of the object
+     * @param value - The value of the object
+     * @param contentType - The content type of the object
+     * @returns The object from the storage
+     */
+    putObject: <T = Uint8Array>(key: string, value: T, contentType?: string) => Promise<void>;
+    /**
+     * Delete the object from the storage
+     * @param key - The key of the object
+     * @returns The object from the storage
+     */
+    deleteObject: (key: string) => Promise<void>;
+}
+type StorageOptions<T extends BaseStorageProviderOptions> = {
+    /**
+     * The default provider to use
+     */
+    defaultProvider: keyof T;
+};
+/**
+ * Mapping of the storage provider options
+ */
+interface BaseStorageProviderOptions {
+    local?: LocalStorageProvider;
+    s3?: S3StorageProvider;
+    azureBlobStorage?: AzureBlobStorageProvider;
+}
+/**
+ * Custom storage providers
+ */
+interface CustomStorageProviderOptions {
+    [key: string]: StorageInterface;
+}
+type StorageProviderOptions = CustomStorageProviderOptions & BaseStorageProviderOptions;
+
+type BlobStorageProviderOptions = {
+    /**
+     * The container name
+     */
+    containerName: string;
+    /**
+     * The connection string to the storage account
+     */
+    connectionString: string;
+    /**
+     * The storage account name
+     */
+    storageAccountName: string;
+    /**
+     * The storage account key
+     */
+    storageAccountKey: string;
+};
+declare class AzureBlobStorageProvider implements StorageInterface {
+    private readonly options;
+    private azureBlobLib;
+    private blobServiceClient;
+    private containerClient;
+    private sharedKeyCredential;
+    constructor(options: BlobStorageProviderOptions);
+    getDownloadUrl(key: string, expiresInSeconds?: number): Promise<string>;
+    getUploadUrl(key: string, expiresInSeconds?: number): Promise<string>;
+    listObjects(prefix?: string): Promise<string[]>;
+    getObject<R extends ReturnType$1 = "raw">(key: string, returnType?: R): Promise<ReturnTypeMap<R>>;
+    putObject<T = Uint8Array>(key: string, value: T, contentType?: string): Promise<void>;
+    deleteObject(key: string): Promise<void>;
+    private ensureClient;
+}
+
+declare class Storage<T extends StorageProviderOptions> implements StorageInterface {
+    private readonly providerOptions;
+    private readonly defaultProvider;
+    private readonly providerMap;
+    constructor(providerOptions: T, storageOptions: StorageOptions<T>);
+    /**
+     * Use a specific provider
+     * @param provider - The provider to use
+     * @returns The storage instance
+     */
+    use(provider: keyof T): StorageInterface;
+    getDownloadUrl(key: string, expiresInSeconds?: number): Promise<string>;
+    getUploadUrl(key: string, expiresInSeconds?: number): Promise<string>;
+    listObjects(prefix?: string): Promise<string[]>;
+    getObject<R extends ReturnType$1 = "raw">(key: string, returnType?: R): Promise<ReturnTypeMap<R>>;
+    putObject<T = Buffer<ArrayBufferLike>>(key: string, value: T, contentType?: string): Promise<void>;
+    deleteObject(key: string): Promise<void>;
+}
+
+/**
+ * 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>;
+}
+
+/**
+ * Compression middleware for gzip compression of response bodies
+ *
+ * @param options Compression middleware options
+ */
+declare const compression: (options?: CompressionOptions) => ServerRouteMiddleware;
+
+/**
+ * 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;
+
+/**
+ * CORS plugin
+ *
+ * ⚠️ SECURITY WARNING: By default, this plugin allows ALL origins ('*').
+ * For production environments, explicitly configure allowed origins.
+ *
+ * @param options CORS options (all optional)
+ *
+ * @example
+ * // Development (permissive)
+ * cors()
+ *
+ * @example
+ * // Production (secure)
+ * cors({
+ *   origin: ['https://example.com', 'https://app.example.com'],
+ *   credentials: true
+ * })
+ */
+declare const cors: (options?: CorsOptions) => ServerRouteMiddleware;
+
+/**
+ * Converts an Express middleware to a Balda middleware
+ */
+declare function expressMiddleware(expressHandler: RequestHandler, basePath?: string): ServerRouteMiddleware;
+/**
+ * Converts an Express handler to a Balda handler
+ */
+declare function expressHandler(handler: RequestHandler, basePath?: string): ServerRouteHandler;
+/**
+ * Mounts an Express router at a specific base path
+ * This extracts all routes from the Express router and registers them with Balda
+ */
+declare function mountExpressRouter(basePath: string, expressRouter: Router$1): void;
+/**
+ * Creates an Express adapter that provides a use method for mounting Express middleware/routers
+ *
+ * @example
+ * ```ts
+ * import AdminJS from 'adminjs'
+ * import AdminJSExpress from '@adminjs/express'
+ * import { createExpressAdapter } from 'balda'
+ *
+ * const admin = new AdminJS({...})
+ * const adminRouter = AdminJSExpress.buildRouter(admin)
+ *
+ * const server = new Server()
+ * const express = createExpressAdapter(server)
+ * express.use('/admin', adminRouter)
+ * ```
+ */
+declare function createExpressAdapter(server: {
+    use: (...middlewares: ServerRouteMiddleware[]) => void;
+}): {
+    use(pathOrMiddleware: string | RequestHandler | Router$1, maybeMiddleware?: RequestHandler | Router$1): void;
+};
+
+/**
+ * Middleware to handle multipart/form-data file uploads with security validations.
+ *  - Validates files against `FilePluginOptions`: size limits, file count, MIME types.
+ *  - Sanitizes filenames to prevent path traversal attacks.
+ *  - Uses cryptographically secure random filenames (UUID) in temporary storage.
+ *  - Stores uploaded files in a runtime-agnostic temporary directory and exposes them via `req.files`.
+ *  - Automatically cleans up temporary files after request completion or on error.
+ *  - Can be used as global middleware or route-specific middleware.
+ */
+declare const fileParser: (options?: FilePluginOptions) => ServerRouteMiddleware;
+
+/**
+ * Sets common HTTP security headers
+ * @param options Helmet options (all optional)
+ */
+declare const helmet: (options?: HelmetOptions) => 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.
+ * @param options.sizeLimit - The maximum size of the JSON body. Default: 100kb
+ */
+declare const json: (options?: JsonOptions) => 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;
+
+/**
+ * Method override middleware for supporting HTTP verbs like PUT/DELETE in clients that don't support them
+ *
+ * @param options Method override middleware options
+ */
+declare const methodOverride: (options?: MethodOverrideOptions) => 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$1) => ServerRouteMiddleware;
+
+/**
+ * Session plugin middleware, used to store the session in the request and response objects
+ * Uses cookies to send the session id
+ * @warning Must be used after the cookie middleware
+ * @param options Session options
+ * @param options.name The name of the session cookie
+ * @param options.ttl The TTL of the session in seconds
+ * @param options.store The store to use for the session
+ * @param options.cookie The cookie options
+ */
+declare const session: (options?: SessionOptions) => ServerRouteMiddleware;
+
+/**
+ * Creates a static file serving middleware and registers all routes for the given path
+ * @param options - The options for serving static files
+ * @param options.source - The file system directory path where the assets are located
+ * @param options.path - The URL path where the assets will be served
+ * @param swaggerOptions - Optional swagger documentation options
+ * @example
+ * serveStatic({ source: 'tmp/assets', path: '/assets' }) // Serves from ./tmp/assets at /assets/*
+ *
+ * @example
+ * serveStatic({ source: 'public', path: '/public' }) // Serves from ./public at /public/*
+ */
+declare const serveStatic: (options: StaticPluginOptions, swaggerOptions?: SwaggerRouteOptions) => ServerRouteMiddleware;
+declare function getContentType(ext: string): string;
+
+/**
+ * Timeout plugin middleware, used to timeout the request if it takes too long
+ * It fills the req.timeout property with true if the request times out
+ * @param options Timeout options
+ * @param options.ms The timeout in milliseconds
+ * @param options.status The status code to return if the request times out
+ * @param options.message The message to return if the request times out
+ */
+declare const timeout: (options: TimeoutOptions) => ServerRouteMiddleware;
+
+/**
+ * Trust proxy plugin middleware, used to trust the proxy headers to get the client ip
+ * @param options Trust proxy options (all optional)
+ * @param options.trust Whether to trust the proxy headers
+ * @param options.header The header name to read the client IP chain from
+ * @param options.hop The hop to use to get the client IP
+ */
+declare const trustProxy: (options?: TrustProxyOptions) => 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. Supports "5mb", "100kb" format. 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;
+
+type PolicyProvider = {
+    [K: string]: (...args: any[]) => Promise<boolean> | boolean;
+};
+type PolicyMetadata = {
+    scope: string;
+    handler: string;
+    manager: PolicyManager<any>;
+};
+type PolicyDecorator<T extends Record<string, PolicyProvider>> = <S extends keyof T & string, H extends keyof T[S] & string>(scope: S, handler: H) => (target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => any;
+
+declare class PolicyManager<T extends Record<string, PolicyProvider>> {
+    private readonly providers;
+    constructor(providers: T);
+    /**
+     * Creates a decorator for the policy manager with typed parameters
+     */
+    createDecorator(): PolicyDecorator<T>;
+    /**
+     * Checks if the user has access to the given scope and handler
+     * @param scope - The scope to check access for
+     * @param handler - The handler to check access for
+     * @param args - The arguments to pass to the handler
+     */
+    canAccess<K extends keyof T, L extends T[K]>(scope: K, handler: keyof L, ...args: Parameters<T[K][keyof T[K]]>): ReturnType<T[K][keyof T[K]]>;
+}
+
+declare const createPolicyDecorator: <T extends Record<string, PolicyProvider>>(manager: PolicyManager<T>) => PolicyDecorator<T>;
+
+/**
+ * Singleton main router instance that handles all route registrations inside the balda server
+ */
+declare const router: ClientRouter;
+
+export { ARG_SYMBOL, AzureBlobStorageProvider, BaseCron, BaseMqtt, BasePlugin, BaseQueue, type BaseStorageProviderOptions, type BlobStorageProviderOptions, BullMQConfiguration, type BullMQConfigurationOptions, BullMQPubSub, type BunTapOptions, Command, type CommandOptions, CommandRegistry, type CronSchedule, type CronScheduleParams, CronService, type CustomQueueConfiguration, type CustomStorageProviderOptions, type CustomValidationError, type DenoTapOptions, type ExpressAdapterOptions, type ExpressHandler, type ExpressRouter, type FileAllowedMimeType, GraphQL, type GraphQLContext, type GraphQLOptions, type GraphQLResolverFunction, type GraphQLResolverMap, type GraphQLResolverType, type GraphQLResolvers, type GraphQLSchemaInput, type GraphQLTypeDef, type HttpMethod, type HttpsOptions, LocalStorageProvider, type LocalStorageProviderOptions, type LoggerOptions, MockServer, type MockServerOptions, type MqttConnectionOptions, type MqttHandler, type MqttPublishOptions, MqttService, type MqttSubscribeOptions, type MqttSubscription, type MqttTopics, type NextFunction, type NodeHttpClient, type NodeServer, type NodeTapOptions, PGBossConfiguration, type PGBossConfigurationOptions, PGBossPubSub, type PGBossSendOptions, type PolicyDecorator, PolicyManager, type PolicyMetadata, type PolicyProvider, type PubSub, type PublishOptions, QueueManager, type QueueProvider, type QueueProviderKey, QueueService, type QueueTopic, type QueueTopicKey, Request$1 as Request, type ResolvedServerOptions, Response$1 as Response, type ReturnType$1 as ReturnType, type ReturnTypeMap, type RuntimeServer, type RuntimeServerMap, S3StorageProvider, type S3StorageProviderOptions, SQSConfiguration, type SQSConfigurationOptions, SQSPubSub, type SQSPublishOptions, type SerializeOptions, Server, type ServerConnectInput, type ServerErrorHandler, type ServerInterface, type ServerListenCallback, type ServerOptions, type ServerPlugin, type ServerRoute, type ServerRouteHandler, type ServerRouteMiddleware, type ServerTapOptions, type ServerTapOptionsBuilder, type SignalEvent, type StandardMethodOptions, type StaticPluginOptions, Storage, type StorageInterface, type StorageOptions, type StorageProviderOptions, VALIDATION_ERROR_SYMBOL, type ValidationOptions, arg, asyncLocalStorage, asyncStorage, baseCommands, commandRegistry, compression, controller, cookie, cors, createExpressAdapter, createPolicyDecorator, cron, defineLoggerConfig, defineQueueConfiguration, del, expressHandler, expressMiddleware, fileParser, flag, get, getContentType, hash, helmet, json, log, logger, methodOverride, middleware, mountExpressRouter, mqtt, patch, post, publish, put, queue, rateLimiter, router, serialize, serveStatic, session, setCronGlobalErrorHandler, setMqttGlobalErrorHandler, timeout, trustProxy, urlencoded, validate };