balda 0.0.13 → 0.0.15

package/lib/index.d.ts

@@ -1,17 +1,17 @@
-import { schedule, TaskContext } from 'node-cron';
-import { ZodType, z } from 'zod';
-import { TSchema, Static } from '@sinclair/typebox';
-import { Ajv } from 'ajv';
+import { IRouter, RequestHandler, Router as Router$1 } from 'express';
+export { ErrorRequestHandler as ExpressErrorMiddleware, RequestHandler as ExpressMiddleware, NextFunction as ExpressNextFunction, Request as ExpressRequest, Response as ExpressResponse } from 'express';
+import { GraphQLSchema } from 'graphql';
+import { createSchema, createYoga } from 'graphql-yoga';
 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 { Ajv } from 'ajv';
+import { ZodType, z } from 'zod';
+import { TSchema, Static } from '@sinclair/typebox';
 import * as pino from 'pino';
 import pino__default, { pino as pino$1 } from 'pino';
+import { schedule, TaskContext } from 'node-cron';
 import { IClientSubscribeOptions, IClientOptions, IClientPublishOptions, MqttClient } from 'mqtt';
 import { SQSClientConfig, SendMessageCommandInput } from '@aws-sdk/client-sqs';
 import { Queue, JobsOptions, Job } from 'bullmq';
@@ -19,412 +19,227 @@ import { SendOptions } from 'pg-boss';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { S3Client } from '@aws-sdk/client-s3';
 
-type CronSchedule = {
-    name: string;
-    args: Parameters<typeof schedule>;
+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 CronScheduleParams = Parameters<typeof schedule>;
+type GraphQLResolverType = "Query" | "Mutation" | "Subscription";
 
-/**
- * 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;
+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;
+}
 
-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 = {
+type SyncOrAsync<T = void> = T | Promise<T>;
+
+type AjvInstance = InstanceType<typeof Ajv>;
+type AjvCompileParams = Parameters<AjvInstance["compile"]>;
+
+type RequestSchema = ZodType | TSchema | AjvCompileParams[0];
+type ValidatedData<T extends RequestSchema> = T extends ZodType ? z.infer<T> : T extends TSchema ? Static<T> : T extends AjvCompileParams[0] ? any : any;
+interface CustomValidationError {
+    status?: number;
+    message?: string;
+}
+interface ValidationOptions {
     /**
-     * The description of the argument.
+     * The schema to validate the request body against (Zod, TypeBox, or plain JSON schema)
      */
-    description?: string;
+    body?: RequestSchema;
     /**
-     * Whether the argument is required.
+     * The schema to validate the query parameters against (Zod, TypeBox, or plain JSON schema)
+     */
+    query?: RequestSchema;
+    /**
+     * The schema to validate both body and query against (Zod, TypeBox, or plain JSON schema)
+     */
+    all?: RequestSchema;
+    /**
+     * Whether to use safe validation (returns original data if validation fails instead of throwing)
      * @default false
      */
-    required?: boolean;
+    safe?: boolean;
+}
+
+type StaticPluginOptions = {
     /**
-     * The default value of the argument.
+     * The file system directory path where the assets are located
+     * @example "./tmp/assets" or "public"
      */
-    defaultValue?: string;
+    source: string;
     /**
-     * A function to parse the argument value.
-     * @default The value is returned as is.
+     * The URL path where the assets will be served
+     * @example "/assets" or "/public"
      */
-    parse?: (value: string) => string;
+    path: string;
 };
-type FlagOptions<T extends FlagType> = {
+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 description of the flag.
+     * The name of the form field.
      */
-    description?: string;
+    formName: string;
     /**
-     * The type of the flag.
+     * The mime type of the file. (e.g. "image/png")
      */
-    type: T;
+    mimeType: string;
     /**
-     * The name of the flag.
-     * @default The name of the field.
+     * The size of the file in bytes.
      */
-    name?: string;
+    size: number;
     /**
-     * The aliases of the flag.
+     * The temporary path of the file. Will be deleted after the request is processed automatically even in error cases.
      */
-    aliases?: string[] | string;
+    tmpPath: string;
     /**
-     * The default value of the flag.
+     * The original filename (including extension) as sent by the client
+     * (e.g. "avatar.png", "document.txt").
      */
-    defaultValue?: InferFlagType<T>;
+    originalName: string;
+};
+type FilePluginOptions = {
     /**
-     * Whether the flag is required.
-     * @default false
+     * The maximum size of each file.
+     * Supports formats like "5mb", "100kb".
+     * Example: "10mb", "500kb"
+     * Default: 1mb
      */
-    required?: boolean;
+    maxFileSize?: `${number}mb` | `${number}kb`;
     /**
-     * A function to parse the flag value.
-     * @default The value is returned as is.
+     * The maximum number of files allowed in a single request.
      */
-    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;
+    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 & {}))[];
 };
 
 /**
- * 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
+ * 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.
  */
-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 RequestSchema = ZodType | TSchema | AjvCompileParams[0];
-type ValidatedData<T extends RequestSchema> = T extends ZodType ? z.infer<T> : T extends TSchema ? Static<T> : T extends AjvCompileParams[0] ? any : any;
-interface CustomValidationError {
-    status?: number;
-    message?: string;
-}
-interface ValidationOptions {
-    /**
-     * The schema to validate the request body against (Zod, TypeBox, or plain JSON schema)
-     */
-    body?: RequestSchema;
+declare class Request<Params extends Record<string, string> = any> {
+    #private;
     /**
-     * The schema to validate the query parameters against (Zod, TypeBox, or plain JSON schema)
+     * Creates a new request object from a Web API Request object.
+     * Optimized to inline body check and avoid unnecessary property spreading.
+     * @param request - The Web API Request object to create a new request object from.
+     * @returns The new request object.
      */
-    query?: RequestSchema;
+    static fromRequest(request: globalThis.Request): Request;
     /**
-     * The schema to validate both body and query against (Zod, TypeBox, or plain JSON schema)
+     * Convert this request back to a Web API Request object.
+     * Useful for passing to external libraries that expect standard Request objects.
+     * @returns A Web API Request object
      */
-    all?: RequestSchema;
+    toWebApi(): globalThis.Request;
     /**
-     * Whether to use safe validation (returns original data if validation fails instead of throwing)
-     * @default false
+     * Compiles and validates the request data against the input schema.
+     * @param inputSchema - The schema to validate the request data against (Zod, TypeBox, or plain JSON schema).
+     * @param data - The request data to validate.
+     * @param safe - If true, the function will return the original data if the validation fails instead of throwing an error.
+     * @returns The validated data.
      */
-    safe?: boolean;
-}
-
-type SyncOrAsync<T = void> = T | Promise<T>;
-
-interface AsyncLocalStorageContext {
-}
-type AsyncLocalStorageContextSetters<K extends keyof AsyncLocalStorageContext = keyof AsyncLocalStorageContext> = Record<K, (req: Request) => SyncOrAsync<AsyncLocalStorageContext[K]>>;
-
-type StaticPluginOptions = {
+    private static compileAndValidate;
     /**
-     * The file system directory path where the assets are located
-     * @example "./tmp/assets" or "public"
+     * The URL of the request
      */
-    source: string;
+    url: string;
     /**
-     * The URL path where the assets will be served
-     * @example "/assets" or "/public"
+     * The HTTP method of the request
      */
-    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 = {
+    method: string;
     /**
-     * The name of the form field.
+     * The headers of the request
      */
-    formName: string;
+    headers: globalThis.Headers;
     /**
-     * The mime type of the file. (e.g. "image/png")
+     * The signal for aborting the request
      */
-    mimeType: string;
+    signal?: AbortSignal;
     /**
-     * The size of the file in bytes.
+     * The referrer of the request
      */
-    size: number;
+    referrer?: string;
     /**
-     * The temporary path of the file. Will be deleted after the request is processed automatically even in error cases.
+     * The referrer policy of the request
      */
-    tmpPath: string;
+    referrerPolicy?: ReferrerPolicy;
     /**
-     * The original filename (including extension) as sent by the client
-     * (e.g. "avatar.png", "document.txt").
+     * The mode of the request
      */
-    originalName: string;
-};
-type FilePluginOptions = {
+    mode?: RequestMode;
     /**
-     * The maximum size of each file.
-     * Supports formats like "5mb", "100kb".
-     * Example: "10mb", "500kb"
-     * Default: 1mb
+     * The credentials mode of the request
      */
-    maxFileSize?: `${number}mb` | `${number}kb`;
+    credentials?: RequestCredentials;
     /**
-     * The maximum number of files allowed in a single request.
+     * The cache mode of the request
      */
-    maxFiles?: number;
+    cache?: RequestCache;
     /**
-     * Allowed MIME types for uploaded files.
-     * If specified, only files with these MIME types will be accepted.
-     * Example: ['image/jpeg', 'image/png', 'application/pdf']
+     * The redirect mode of the request
      */
-    allowedMimeTypes?: (FileAllowedMimeType | (string & {}))[];
-};
-
-/**
- * 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<Params extends Record<string, string> = any> extends globalThis.Request {
-    #private;
+    redirect?: RequestRedirect;
     /**
-     * Creates a new request object from a Web API Request object.
-     * @param request - The Web API Request object to create a new request object from.
-     * @returns The new request object.
+     * The integrity of the request
      */
-    static fromRequest(request: globalThis.Request): Request;
+    integrity?: string;
     /**
-     * Compiles and validates the request data against the input schema.
-     * @param inputSchema - The schema to validate the request data against (Zod, TypeBox, or plain JSON schema).
-     * @param data - The request data to validate.
-     * @param safe - If true, the function will return the original data if the validation fails instead of throwing an error.
-     * @returns The validated data.
+     * The keepalive flag of the request
      */
-    private static compileAndValidate;
+    keepalive?: boolean;
     /**
-     * The raw Web API Request body.
-     * @warning if using body parser middleware, this property will be read and the parsed body will be set to the `parsedBody` property.
-     * @warning this body can be read once so be careful not to use it after the body parser middleware has been applied.
+     * The parsed body of the request from the body parser middleware.
+     * If body parser middleware is not used, this will be undefined.
      */
-    readonly body: globalThis.Request["body"];
+    body: any;
     /**
-     * The parsed body of the request from the body parser middleware.
+     * Flag indicating if the body has been read/parsed
      */
-    parsedBody: any;
+    bodyUsed: boolean;
     /**
      * The context of the request. Can be augmented extending AsyncLocalStorageContext interface
      * @asyncLocalStorage middleware is required
@@ -528,24 +343,103 @@ declare class Request<Params extends Record<string, string> = any> extends globa
     validateAll<T extends RequestSchema>(inputSchema: T, safe?: boolean): ValidatedData<T>;
 }
 
-/**
- * Cookie options for setting cookies
- */
-type CookieOptions = {
+interface AsyncLocalStorageContext {
+}
+type AsyncLocalStorageContextSetters<K extends keyof AsyncLocalStorageContext = keyof AsyncLocalStorageContext> = Record<K, (req: Request) => SyncOrAsync<AsyncLocalStorageContext[K]>>;
+
+interface JsonOptions {
     /**
-     * Domain for the cookie
+     * The maximum size of the JSON body in bytes.
+     * If the body is larger than this limit, the request will be rejected.
+     * Default: 100kb
      */
-    domain?: string;
+    sizeLimit?: `${number}mb` | `${number}kb`;
     /**
-     * Path for the cookie
+     * If true, the JSON body will be parsed as an empty object if it is empty.
+     * Default: false (body will be undefined)
      */
-    path?: string;
+    parseEmptyBodyAsObject?: boolean;
     /**
-     * Expiration date for the cookie
+     * 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" }
      */
-    expires?: Date;
+    customErrorMessage?: {
+        status?: number;
+        message?: string;
+    };
+}
+
+/**
+ * Options for URL-encoded middleware
+ */
+type UrlEncodedOptions = {
     /**
-     * Max age in seconds for the cookie
+     * 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;
+};
+
+type BodyParserOptions = {
+    json?: JsonOptions;
+    urlencoded?: UrlEncodedOptions;
+    fileParser?: FilePluginOptions;
+};
+
+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[];
+};
+
+/**
+ * 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;
     /**
@@ -603,1003 +497,772 @@ type CookieMiddlewareOptions = {
     sign?: boolean;
 };
 
+type CorsMethods = "GET" | "POST" | "PUT" | "DELETE" | "OPTIONS" | "PATCH" | "HEAD";
 /**
- * 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.
+ * Options for CORS middleware, similar to Express.js
  */
-declare class Response$1 {
-    static toWebResponse(response: Response$1): globalThis.Response;
+type CorsOptions = {
     /**
-     * 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
+     * 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.
      */
-    nodeResponse: ServerResponse;
+    origin?: string | RegExp | (string | RegExp)[];
     /**
-     * The status of the response
+     * Configures the Access-Control-Allow-Methods CORS header. Defaults to 'GET,HEAD,PUT,PATCH,POST,DELETE'.
      */
-    responseStatus: number;
+    methods?: CorsMethods[] | string;
     /**
-     * The headers of the response
+     * Configures the Access-Control-Allow-Headers CORS header. Defaults to allowing all requested headers.
      */
-    headers: Record<string, string>;
+    allowedHeaders?: string[] | string;
     /**
-     * The body of the response
+     * Configures the Access-Control-Expose-Headers CORS header. Defaults to none.
      */
-    private body;
-    constructor(status?: number);
+    exposedHeaders?: string[] | string;
     /**
-     * Set a header for the response
+     * Configures the Access-Control-Allow-Credentials CORS header. Defaults to false.
      */
-    setHeader(key: string, value: string): this;
+    credentials?: boolean;
     /**
-     * Set the status of the response, status defaults to 200
+     * Configures the Access-Control-Max-Age CORS header. Defaults to undefined (not sent).
      */
-    status(status: number): this;
+    maxAge?: number;
     /**
-     * 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
+     * Pass the CORS preflight response to the next handler. Defaults to false (ends response).
      */
-    send(body: any): void;
+    preflightContinue?: boolean;
     /**
-     * Send a response with the given body without any content type or encoding (as is), status defaults to 200
+     * Provides a status code to use for successful OPTIONS requests, if preflightContinue is false. Defaults to 204.
      */
-    raw(body: any): void;
+    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;
+}
+
+type LoggerOptions = Parameters<typeof pino$1>[0];
+
+interface LogOptions {
     /**
-     * Send a response with the given text, status defaults to 200
+     * Whether to log the request.
+     * @default true
      */
-    text(body: string): void;
+    logRequest?: boolean;
     /**
-     * Send a response with the given JSON, status defaults to 200
+     * What to log for the request.
+     * @default true for all properties
      */
-    json<T extends Record<string, unknown> | Array<unknown>>(body: T): void;
+    requestPayload?: {
+        method?: boolean;
+        url?: boolean;
+        ip?: boolean;
+        headers?: boolean;
+        /** Only json objects and strings are logged */
+        body?: boolean;
+    };
     /**
-     * Send a response with the given HTML, status defaults to 200
+     * Whether to log the response.
+     * @default true
      */
-    html(htmlString: string): void;
+    logResponse?: boolean;
     /**
-     * Send a response with the given XML, status defaults to 200
+     * Whether to log the response body.
+     * @default false
      */
-    xml(body: string): void;
+    responsePayload?: {
+        status?: boolean;
+        headers?: boolean;
+        body?: boolean;
+    };
     /**
-     * Send a response with the given binary with Content-Type of application/octet-stream header, status defaults to 200
+     * What to log for the response.
+     * @default true for all properties
      */
-    download(body: Uint8Array | Buffer): void;
+    pinoOptions?: LoggerOptions;
+}
+
+type MethodOverrideOptions = {
     /**
-     * Send a response with the given file content, status defaults to 200
-     * @param options only affects node and bun environment
+     * HTTP methods that can be overridden
+     * Default: ['POST']
      */
-    file(pathToFile: string, options?: {
-        encoding?: string;
-        flag?: string;
-    }): void;
+    methods?: string[];
     /**
-     * 2XX Success
+     * Header name to read the override method from
+     * Default: 'X-HTTP-Method-Override'
      */
+    header?: string;
+};
+
+type StorageStrategy = "memory" | "custom";
+type BaseRateLimiterOptions = {
     /**
-     * 200 OK
+     * The number of requests per window
+     * @default 100
      */
-    ok(body?: any): void;
+    limit?: number;
     /**
-     * 201 Created
+     * The message to return when the rate limit is exceeded
+     * @default "ERR_RATE_LIMIT_EXCEEDED"
      */
-    created(body?: any): void;
+    message?: string;
     /**
-     * 202 Accepted
+     * The status code to return when the rate limit is exceeded
+     * @default 429
      */
-    accepted(body?: any): void;
+    statusCode?: number;
     /**
-     * 204 No Content
+     * The storage strategy to use
+     * @default "memory"
      */
-    noContent(): void;
+    storageStrategy?: StorageStrategy;
+};
+/**
+ * Key Strategy
+ */
+type IpRateLimiterOptions = {
     /**
-     * 206 Partial Content
+     * The type of rate limiter
      */
-    partialContent(body?: any): void;
+    type: "ip";
+} & BaseRateLimiterOptions;
+type CustomRateLimiterOptions = {
     /**
-     * 3XX Redirection
+     * The type of rate limiter
      */
+    type: "custom";
     /**
-     * 300 Multiple Choices
+     * Generate a key for the rate limiter from the request (e.g. user id, email, etc.)
      */
-    multipleChoices(url: string): void;
-    redirect(url: string): void;
+    key: (req: Request) => string;
     /**
-     * 301 Moved Permanently
+     * The storage strategy to use
+     * @default "memory"
      */
-    movedPermanently(url: string): void;
+    storageStrategy?: StorageStrategy;
+} & BaseRateLimiterOptions;
+/**
+ * Memory Storage Strategy
+ */
+type MemoryStorageStrategy = {
     /**
-     * 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
+     * The type of storage strategy
      */
-    httpVersionNotSupported(body?: any): void;
+    type: "memory";
     /**
-     * Set a cookie for the response, cookie middleware must be registered in order to use this function
+     * The window in milliseconds
+     * @default 60000
      */
-    cookie?(_name: string, _value: string, _options?: CookieOptions): void;
+    windowMs?: number;
+};
+/**
+ * Custom Storage Strategy
+ */
+type CustomStorageStrategy = {
     /**
-     * Clear a cookie for the response, cookie middleware must be registered in order to use this function
+     * The type of storage strategy
      */
-    clearCookie?(_name: string, _options?: CookieOptions): void;
+    type: "custom";
     /**
-     * Stream a response using an async generator or ReadableStream
-     * Sets appropriate headers for Server-Sent Events by default
+     * Set a value in the storage
      */
-    stream(source: AsyncGenerator<any> | Generator<any> | ReadableStream, options?: {
-        customHeaders?: Record<string, string>;
-    }): void;
+    set: (key: string, value: any) => Promise<void>;
     /**
-     * Get the body of the response
+     * Get a value from the storage
      */
-    getBody(): any;
-}
-
-type DelHandler = (req: Request, res: Response$1, ...args: any[]) => any;
+    get: (key: string) => Promise<any>;
+};
+type StorageOptions$1 = MemoryStorageStrategy | CustomStorageStrategy;
 /**
- * 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) {
- *     // ...
- *   }
- * }
- * ```
+ * Rate limiter options
  */
-declare const del: (path: string, options?: SwaggerRouteOptions) => <T extends DelHandler>(target: any, propertyKey: string, descriptor: PropertyDescriptor) => TypedPropertyDescriptor<T>;
+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;
+    };
+};
 
-type GetHandler = (req: Request, 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) {
- *     // ...
- *   }
- * }
- * ```
+ * Type of Swagger UI to use
  */
-declare const get: (path: string, options?: SwaggerRouteOptions) => <T extends GetHandler>(target: any, propertyKey: string, descriptor: PropertyDescriptor) => TypedPropertyDescriptor<T>;
-
-type PatchHandler = (req: Request, res: Response$1, ...args: any[]) => any;
+type SwaggerUIType = "standard" | "rapidoc" | "scalar" | "elements" | "custom";
+type HTMLString = string;
 /**
- * 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) {
- *     // ...
- *   }
- * }
- * ```
+ * Custom UI generator function that takes the spec URL and global options and returns HTML
  */
-declare const patch: (path: string, options?: SwaggerRouteOptions) => <T extends PatchHandler>(target: any, propertyKey: string, descriptor: PropertyDescriptor) => TypedPropertyDescriptor<T>;
-
-type PostHandler = (req: Request, res: Response$1, ...args: any[]) => any;
+type CustomUIGenerator = (specUrl: string, globalOptions: SwaggerGlobalOptions) => HTMLString;
 /**
- * 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) {
- *     // ...
- *   }
- * }
- * ```
+ * Type of request body for a route
  */
-declare const post: (path: string, options?: SwaggerRouteOptions) => <T extends PostHandler>(target: any, propertyKey: string, descriptor: PropertyDescriptor) => TypedPropertyDescriptor<T>;
-
-type PutHandler = (req: Request, res: Response$1, ...args: any[]) => any;
+type SwaggerBodyType = "json" | "form-data" | "urlencoded";
 /**
- * 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) {
- *     // ...
- *   }
+ * JSONSchema type for OpenAPI/AJV-compatible schemas
  */
-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 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;
 };
-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];
+/**
+ * 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;
+        };
+    };
     /**
-     * Add a type definition to the schema
+     * OpenAPI models to be shown in the documentation. Must be valid OpenAPI/AJV JSONSchema objects.
      */
-    addTypeDef(typeDef: GraphQLTypeDef): void;
+    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;
     /**
-     * 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
+     * The request body type for this route. Allowed values: 'json', 'form-data', 'urlencoded'. Defaults to 'json'.
      */
-    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;
-}
+    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;
+};
 
 /**
- * Singleton that handles the routing of requests to the appropriate handler(s).
+ * 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 class Router {
-    private trees;
-    private routes;
-    private middlewares;
-    private basePath;
-    private staticRouteCache;
-    /**
-     * 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.
-     * Uses O(1) cache lookup for static routes, falls back to O(k) tree traversal for dynamic routes.
-     */
-    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;
+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";
+};
+
+/**
+ * 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;
+
+/**
+ * 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 {
+    static toWebResponse(response: Response$1): globalThis.Response;
     /**
-     * Register a DELETE route under this router's base path.
+     * 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
      */
-    delete(path: string, handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
-    delete(path: string, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    nodeResponse: ServerResponse;
     /**
-     * Register an OPTIONS route under this router's base path.
+     * The status of the response
      */
-    options(path: string, handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
-    options(path: string, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    responseStatus: number;
     /**
-     * Register an HEAD route under this router's base path.
+     * The headers of the response
      */
-    head(path: string, handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
-    head(path: string, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    headers: Record<string, string>;
     /**
-     * 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.
+     * The body of the response
      */
-    group(path: string, middleware: ServerRouteMiddleware[] | ServerRouteMiddleware, cb: (router: Router) => void): void;
-    group(path: string, cb: (router: Router) => void): void;
+    private body;
+    constructor(status?: number);
     /**
-     * Apply global middlewares to all routes
-     * @param middlewares - The middlewares to apply
-     * @internal
+     * Set a header for the response
      */
-    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 {
-    readonly _brand: "BaldaServer";
-    isListening: boolean;
-    isProduction: boolean;
-    graphql: GraphQL;
-    readonly serverOptions: ResolvedServerOptions;
-    readonly router: ClientRouter;
-    private wasInitialized;
-    private serverConnector;
-    private globalMiddlewares;
-    private controllerImportBlacklistedPaths;
-    private notFoundHandler?;
-    private readonly nativeEnv;
-    private httpsOptions?;
+    setHeader(key: string, value: string): this;
     /**
-     * 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
+     * Set the status of the response, status defaults to 200
      */
-    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;
-    setNotFoundHandler(notFoundHandler?: ServerRouteHandler): void;
-    listen(cb?: ServerListenCallback): void;
-    waitUntilListening(): Promise<void>;
-    close(): Promise<void>;
-    disconnect(): Promise<void>;
-    configureHash(options: {
-        iterations?: number;
-        saltLength?: number;
-        keyLength?: number;
-    }): void;
-    getMockServer(options?: Pick<ServerOptions, "controllerPatterns">): Promise<MockServer>;
-    private importControllers;
-    private extractOptionsAndHandlerFromRouteRegistration;
-    private applyPlugins;
+    status(status: number): this;
     /**
-     * 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
+     * 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
      */
-    private bootstrap;
+    send(body: any): void;
     /**
-     * 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
+     * Send a response with the given body without any content type or encoding (as is), status defaults to 200
      */
-    private handleNotFound;
+    raw(body: any): void;
     /**
-     * Registers a not found route for all routes that are not defined
-     * @internal
+     * Send a response with the given text, status defaults to 200
      */
-    private registerNotFoundRoutes;
-}
-
-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 {
+    text(body: string): void;
     /**
-     * The body of the request, if formData is provided, it will be ignored
+     * Send a response with the given JSON, status defaults to 200
      */
-    body?: any;
+    json<T extends Record<string, unknown> | Array<unknown>>(body: T): void;
     /**
-     * The form data of the request
+     * Send a response with the given HTML, status defaults to 200
      */
-    formData?: FormData;
+    html(htmlString: string): void;
     /**
-     * The urlencoded body of the request
+     * Send a response with the given XML, status defaults to 200
      */
-    urlencoded?: Record<string, string>;
+    xml(body: string): void;
     /**
-     * The headers of the request
+     * Send a response with the given binary with Content-Type of application/octet-stream header, status defaults to 200
      */
-    headers?: Record<string, string>;
+    download(body: Uint8Array | Buffer): void;
     /**
-     * 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)
+     * Send a response with the given file content, status defaults to 200
+     * @param options only affects node and bun environment
      */
-    query?: Record<string, string>;
+    file(pathToFile: string, options?: {
+        encoding?: string;
+        flag?: string;
+    }): void;
     /**
-     * The cookies of the request
+     * 2XX Success
      */
-    cookies?: Record<string, string>;
     /**
-     * The ip of the request
+     * 200 OK
      */
-    ip?: string;
-}
-
-/**
- * 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>);
+    ok(body?: any): void;
     /**
-     * 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
+     * 201 Created
      */
-    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>>;
+    created(body?: any): void;
     /**
-     * Converts FormData to a proper multipart/form-data body with boundaries
+     * 202 Accepted
      */
-    private formDataToMultipart;
-    private validateOptions;
-}
-
-type CompressionOptions = {
+    accepted(body?: any): void;
     /**
-     * Minimum response size in bytes to trigger compression
-     * Default: 1024 (1KB)
+     * 204 No Content
      */
-    threshold?: number;
+    noContent(): void;
     /**
-     * Compression level (0-9)
-     * 0 = no compression, 9 = maximum compression
-     * Default: 6
+     * 206 Partial Content
      */
-    level?: number;
+    partialContent(body?: any): void;
     /**
-     * Content types to compress (regex patterns)
-     * Default: common compressible types (text, json, xml, javascript, etc.)
+     * 3XX Redirection
      */
-    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.
+     * 300 Multiple Choices
      */
-    origin?: string | RegExp | (string | RegExp)[];
+    multipleChoices(url: string): void;
+    redirect(url: string): void;
     /**
-     * Configures the Access-Control-Allow-Methods CORS header. Defaults to 'GET,HEAD,PUT,PATCH,POST,DELETE'.
+     * 301 Moved Permanently
      */
-    methods?: CorsMethods[] | string;
+    movedPermanently(url: string): void;
     /**
-     * Configures the Access-Control-Allow-Headers CORS header. Defaults to allowing all requested headers.
+     * 302 Found (Temporary Redirect)
      */
-    allowedHeaders?: string[] | string;
+    found(url: string): void;
     /**
-     * Configures the Access-Control-Expose-Headers CORS header. Defaults to none.
+     * 303 See Other
      */
-    exposedHeaders?: string[] | string;
+    seeOther(url: string): void;
     /**
-     * Configures the Access-Control-Allow-Credentials CORS header. Defaults to false.
+     * 304 Not Modified
      */
-    credentials?: boolean;
+    notModified(): void;
     /**
-     * Configures the Access-Control-Max-Age CORS header. Defaults to undefined (not sent).
+     * 307 Temporary Redirect
      */
-    maxAge?: number;
+    temporaryRedirect(url: string): void;
     /**
-     * Pass the CORS preflight response to the next handler. Defaults to false (ends response).
+     * 308 Permanent Redirect
      */
-    preflightContinue?: boolean;
+    permanentRedirect(url: string): void;
     /**
-     * Provides a status code to use for successful OPTIONS requests, if preflightContinue is false. Defaults to 204.
+     * 4XX Client Errors
      */
-    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;
-}
-
-type LoggerOptions = Parameters<typeof pino$1>[0];
-
-interface LogOptions {
     /**
-     * Whether to log the request.
-     * @default true
+     * 400 Bad Request
      */
-    logRequest?: boolean;
+    badRequest(body?: any): void;
     /**
-     * What to log for the request.
-     * @default true for all properties
+     * 401 Unauthorized
      */
-    requestPayload?: {
-        method?: boolean;
-        url?: boolean;
-        ip?: boolean;
-        headers?: boolean;
-        /** Only json objects and strings are logged */
-        body?: boolean;
-    };
+    unauthorized(body?: any): void;
     /**
-     * Whether to log the response.
-     * @default true
+     * 403 Forbidden
      */
-    logResponse?: boolean;
+    forbidden(body?: any): void;
     /**
-     * Whether to log the response body.
-     * @default false
+     * 404 Not Found
      */
-    responsePayload?: {
-        status?: boolean;
-        headers?: boolean;
-        body?: boolean;
-    };
+    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;
     /**
-     * What to log for the response.
-     * @default true for all properties
+     * 415 Unsupported Media Type
      */
-    pinoOptions?: LoggerOptions;
-}
-
-type MethodOverrideOptions = {
+    unsupportedMediaType(body?: any): void;
     /**
-     * HTTP methods that can be overridden
-     * Default: ['POST']
+     * 422 Unprocessable Entity
      */
-    methods?: string[];
+    unprocessableEntity(body?: any): void;
     /**
-     * Header name to read the override method from
-     * Default: 'X-HTTP-Method-Override'
+     * 429 Too Many Requests
      */
-    header?: string;
-};
-
-type StorageStrategy = "memory" | "custom";
-type BaseRateLimiterOptions = {
+    tooManyRequests(body?: any): void;
     /**
-     * The number of requests per window
-     * @default 100
+     * 5XX Server Errors
      */
-    limit?: number;
+    internalServerError(body?: any): void;
     /**
-     * The message to return when the rate limit is exceeded
-     * @default "ERR_RATE_LIMIT_EXCEEDED"
+     * 501 Not Implemented
      */
-    message?: string;
+    notImplemented(body?: any): void;
     /**
-     * The status code to return when the rate limit is exceeded
-     * @default 429
+     * 502 Bad Gateway
      */
-    statusCode?: number;
+    badGateway(body?: any): void;
     /**
-     * The storage strategy to use
-     * @default "memory"
+     * 503 Service Unavailable
      */
-    storageStrategy?: StorageStrategy;
-};
-/**
- * Key Strategy
- */
-type IpRateLimiterOptions = {
+    serviceUnavailable(body?: any): void;
     /**
-     * The type of rate limiter
+     * 504 Gateway Timeout
      */
-    type: "ip";
-} & BaseRateLimiterOptions;
-type CustomRateLimiterOptions = {
+    gatewayTimeout(body?: any): void;
     /**
-     * The type of rate limiter
+     * 505 HTTP Version Not Supported
      */
-    type: "custom";
+    httpVersionNotSupported(body?: any): void;
     /**
-     * Generate a key for the rate limiter from the request (e.g. user id, email, etc.)
+     * Set a cookie for the response, cookie middleware must be registered in order to use this function
      */
-    key: (req: Request) => string;
+    cookie?(_name: string, _value: string, _options?: CookieOptions): void;
     /**
-     * The storage strategy to use
-     * @default "memory"
+     * Clear a cookie for the response, cookie middleware must be registered in order to use this function
      */
-    storageStrategy?: StorageStrategy;
-} & BaseRateLimiterOptions;
-/**
- * Memory Storage Strategy
- */
-type MemoryStorageStrategy = {
+    clearCookie?(_name: string, _options?: CookieOptions): void;
     /**
-     * The type of storage strategy
+     * Stream a response using an async generator or ReadableStream
+     * Sets appropriate headers for Server-Sent Events by default
      */
-    type: "memory";
+    stream(source: AsyncGenerator<any> | Generator<any> | ReadableStream, options?: {
+        customHeaders?: Record<string, string>;
+    }): void;
     /**
-     * The window in milliseconds
-     * @default 60000
+     * Get the body of the response
      */
-    windowMs?: number;
-};
+    getBody(): any;
+}
+
 /**
- * Custom Storage Strategy
+ * Singleton that handles the routing of requests to the appropriate handler(s).
  */
-type CustomStorageStrategy = {
+declare class Router {
+    private trees;
+    private routes;
+    private middlewares;
+    private basePath;
+    private staticRouteCache;
     /**
-     * The type of storage strategy
+     * 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).
      */
-    type: "custom";
+    constructor(basePath?: string, middlewares?: ServerRouteMiddleware[]);
+    /** Returns a shallow copy of all registered routes. */
+    getRoutes(): Route[];
     /**
-     * Set a value in the storage
+     * Add or update a route
+     * @internal
      */
-    set: (key: string, value: any) => Promise<void>;
+    addOrUpdate(method: HttpMethod, path: string, middleware: ServerRouteMiddleware[], handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
     /**
-     * Get a value from the storage
+     * 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.
+     * Uses O(1) cache lookup for static routes, falls back to O(k) tree traversal for dynamic routes.
      */
-    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";
-};
-
-/**
- * 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;
-
-interface JsonOptions {
+    find(method: string, rawPath: string): {
+        middleware: ServerRouteMiddleware[];
+        handler: ServerRouteHandler;
+        params: Params;
+    } | null;
     /**
-     * The maximum size of the JSON body in bytes.
-     * If the body is larger than this limit, the request will be rejected.
-     * Default: 100kb
+     * Register a GET route under this router's base path.
      */
-    sizeLimit?: `${number}mb` | `${number}kb`;
+    get(path: string, handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    get(path: string, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
     /**
-     * If true, the JSON body will be parsed as an empty object if it is empty.
-     * Default: false (body will be undefined)
+     * Register a POST route under this router's base path.
      */
-    parseEmptyBodyAsObject?: boolean;
+    post(path: string, handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    post(path: string, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
     /**
-     * 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" }
+     * Register a PATCH route under this router's base path.
      */
-    customErrorMessage?: {
-        status?: number;
-        message?: string;
-    };
-}
-
-/**
- * Options for URL-encoded middleware
- */
-type UrlEncodedOptions = {
+    patch(path: string, handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    patch(path: string, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
     /**
-     * The maximum size of the URL-encoded body.
-     * Supports formats like "5mb", "100kb".
-     * Defaults to "1mb".
+     * Register a PUT route under this router's base path.
      */
-    limit?: `${number}mb` | `${number}kb`;
+    put(path: string, handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    put(path: string, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
     /**
-     * Whether to parse extended syntax (objects and arrays). Defaults to false.
+     * Register a DELETE route under this router's base path.
      */
-    extended?: boolean;
+    delete(path: string, handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    delete(path: string, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
     /**
-     * The character encoding to use when parsing. Defaults to 'utf8'.
+     * Register an OPTIONS route under this router's base path.
      */
-    charset?: string;
+    options(path: string, handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    options(path: string, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
     /**
-     * Whether to allow empty values. Defaults to true.
+     * Register an HEAD route under this router's base path.
      */
-    allowEmpty?: boolean;
+    head(path: string, handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
+    head(path: string, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: ServerRouteHandler, swaggerOptions?: SwaggerRouteOptions): void;
     /**
-     * Maximum number of parameters to parse. Defaults to 1000.
+     * 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.
      */
-    parameterLimit?: number;
-};
+    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 BodyParserOptions = {
-    json?: JsonOptions;
-    urlencoded?: UrlEncodedOptions;
-    fileParser?: FilePluginOptions;
-};
+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">;
 
 type ServerPlugin = {
     bodyParser?: BodyParserOptions;
@@ -1662,7 +1325,7 @@ type ServerOptions<H extends NodeHttpClient = NodeHttpClient> = {
      */
     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
+     * Custom 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 validation
      * @example
      * ```ts
      * const server = new Server({
@@ -1671,6 +1334,22 @@ type ServerOptions<H extends NodeHttpClient = NodeHttpClient> = {
      * ```
      */
     ajvInstance?: Ajv;
+    /**
+     * An AbortSignal to gracefully shutdown the server when aborted
+     * @example
+     * ```ts
+     * const controller = new AbortController();
+     * const server = new Server({
+     *   abortSignal: controller.signal,
+     * });
+     *
+     * await server.waitUntilListening();
+     *
+     * // Later: abort the server
+     * controller.abort();
+     * ```
+     */
+    abortSignal?: AbortSignal;
 } & (H extends "https" | "http2-secure" ? HttpsOptions<H> : {});
 /** Internal resolved server options with all required properties */
 type ResolvedServerOptions = {
@@ -1682,6 +1361,7 @@ type ResolvedServerOptions = {
     tapOptions: ServerTapOptions;
     swagger: Parameters<typeof swagger>[0] | boolean;
     graphql?: GraphQLOptions;
+    abortSignal?: AbortSignal;
 };
 type ServerErrorHandler = (req: Request, res: Response$1, next: NextFunction, error: Error) => SyncOrAsync;
 interface ServerInterface {
@@ -1766,246 +1446,652 @@ interface ServerInterface {
      */
     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
+     * 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;
+    /**
+     * 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;
+    /**
+     * Binds the server to the port and hostname defined in the serverOptions, meant to be called only once
+     * It initializes the server without blocking the event loop, you can pass a callback to be called when the server is listening
+     * Use `waitUntilListening` instead if you want to wait for the server to be listening for requests before returning
+     * @warning All routes defined with decorators are defined on this method just before the server starts listening for requests
+     */
+    listen: (cb?: ServerListenCallback) => void;
+    /**
+     * Binds the server to the port and hostname defined in the serverOptions, meant to be called only once
+     * It initializes the server blocking the event loop, it will wait for the server to be listening for requests before returning
+     * Use `listen` instead if you want to initialize the server without blocking the event loop
+     * @warning All routes defined with decorators are defined on this method just before the server starts listening for requests
+     */
+    waitUntilListening: () => Promise<void>;
+    /**
+     * Closes the server and frees the port
+     * This method is idempotent and can be called multiple times safely
+     * @alias disconnect
+     */
+    close: () => Promise<void>;
+    /**
+     * Disconnects the server and frees the port
+     * This method is idempotent and can be called multiple times safely
+     * Subsequent calls after the first will have no effect
+     */
+    disconnect: () => Promise<void>;
+    /**
+     * Configure hash settings for password hashing
+     * @param options - Hash configuration options
+     * @param options.iterations - Number of PBKDF2 iterations (default: 600,000)
+     * @param options.saltLength - Salt length in bytes (default: 16)
+     * @param options.keyLength - Key length in bits (default: 256)
+     */
+    configureHash: (options: {
+        iterations?: number;
+        saltLength?: number;
+        keyLength?: number;
+    }) => 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: () => 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, res: Response$1, next: NextFunction) => SyncOrAsync;
+type ServerRouteHandler = (req: Request, 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, 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;
+};
+
+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
      */
-    expressMiddleware: (middleware: RequestHandler) => ServerRouteMiddleware;
+    body?: any;
     /**
-     * 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
+     * The form data of the request
      */
-    mountExpressRouter: (basePath: string, expressRouter: ExpressRouter) => void;
+    formData?: FormData;
     /**
-     * Shorthand for the server.router.get method
+     * The urlencoded body of the request
      */
-    get: (...args: any[]) => void;
+    urlencoded?: Record<string, string>;
     /**
-     * Shorthand for the server.router.post method
+     * The headers of the request
      */
-    post: (...args: any[]) => void;
+    headers?: Record<string, string>;
     /**
-     * Shorthand for the server.router.put method
+     * 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)
      */
-    put: (...args: any[]) => void;
+    query?: Record<string, string>;
     /**
-     * Shorthand for the server.router.patch method
+     * The cookies of the request
      */
-    patch: (...args: any[]) => void;
+    cookies?: Record<string, string>;
     /**
-     * Shorthand for the server.router.delete method
+     * The ip of the request
      */
-    delete: (...args: any[]) => void;
+    ip?: string;
+}
+
+/**
+ * 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>);
     /**
-     * Shorthand for the server.router.options method
+     * 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
      */
-    options: (...args: any[]) => void;
+    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>>;
     /**
-     * Shorthand for the server.router.head method
+     * Converts FormData to a proper multipart/form-data body with boundaries
      */
-    head: (...args: any[]) => void;
+    private formDataToMultipart;
+    private validateOptions;
+}
+
+/**
+ * The server class that is used to create and manage the server
+ */
+declare class Server<H extends NodeHttpClient = NodeHttpClient> implements ServerInterface {
+    #private;
+    readonly _brand: "BaldaServer";
+    readonly serverOptions: ResolvedServerOptions;
+    readonly router: ClientRouter;
+    isListening: boolean;
+    isProduction: boolean;
+    graphql: GraphQL;
     /**
-     * Shorthand for the server.router.group method
+     * 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
+     * @param options.abortSignal - An optional AbortSignal to gracefully shutdown the server when aborted
      */
-    group: (...args: any[]) => void;
+    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;
+    setNotFoundHandler(notFoundHandler?: ServerRouteHandler): void;
+    listen(cb?: ServerListenCallback): void;
+    waitUntilListening(): Promise<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
+     * Closes the server and frees the port
+     * This method is idempotent and can be called multiple times safely
+     * @returns A promise that resolves when the server is closed
      */
-    getNodeServer: () => RuntimeServerMap<"node", NodeHttpClient>;
+    close(): Promise<void>;
     /**
-     * Get the bun server instance, you must be using bun runtime to use this method
-     * @throws if the runtime is not bun
+     * Disconnects the server and frees the port
+     * This method is idempotent and can be called multiple times safely
+     * Subsequent calls after the first will have no effect
+     * @returns A promise that resolves when the server is disconnected
      */
-    getBunServer: () => RuntimeServerMap<"bun">;
+    disconnect(): Promise<void>;
+    configureHash(options: {
+        iterations?: number;
+        saltLength?: number;
+        keyLength?: number;
+    }): void;
+    getMockServer(options?: Pick<ServerOptions, "controllerPatterns">): Promise<MockServer>;
+    private importControllers;
+    private extractOptionsAndHandlerFromRouteRegistration;
+    private applyPlugins;
     /**
-     * Get the deno server instance, you must be using deno runtime to use this method
-     * @throws if the runtime is not deno
+     * 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
      */
-    getDenoServer: () => RuntimeServerMap<"deno">;
+    private bootstrap;
     /**
-     * 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
-     * ```
+     * 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
      */
-    embed: (key: string, value: any) => void;
+    private handleNotFound;
     /**
-     * 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
+     * Registers a not found route for all routes that are not defined
+     * @internal
      */
-    on: (event: SignalEvent, cb: () => SyncOrAsync) => void;
+    private registerNotFoundRoutes;
     /**
-     * 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
+     * Sets up the abort signal handler to gracefully shutdown the server when aborted
+     * @internal
      */
-    once: (event: SignalEvent, cb: () => SyncOrAsync) => void;
+    private setupAbortSignalHandler;
+}
+
+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 = {
     /**
-     * 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
+     * The description of the argument.
      */
-    use: (middleware: ServerRouteMiddleware) => void;
+    description?: string;
     /**
-     * Set the error handler for the server
-     * @param errorHandler - The error handler to be applied to all routes
+     * Whether the argument is required.
+     * @default false
      */
-    setErrorHandler: (errorHandler?: ServerErrorHandler) => void;
+    required?: boolean;
     /**
-     * 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" });
-     * });
+     * The default value of the argument.
      */
-    setNotFoundHandler: (notFoundHandler?: ServerRouteHandler) => void;
+    defaultValue?: string;
     /**
-     * Binds the server to the port and hostname defined in the serverOptions, meant to be called only once
-     * It initializes the server without blocking the event loop, you can pass a callback to be called when the server is listening
-     * Use `waitUntilListening` instead if you want to wait for the server to be listening for requests before returning
-     * @warning All routes defined with decorators are defined on this method just before the server starts listening for requests
+     * A function to parse the argument value.
+     * @default The value is returned as is.
      */
-    listen: (cb?: ServerListenCallback) => void;
+    parse?: (value: string) => string;
+};
+type FlagOptions<T extends FlagType> = {
     /**
-     * Binds the server to the port and hostname defined in the serverOptions, meant to be called only once
-     * It initializes the server blocking the event loop, it will wait for the server to be listening for requests before returning
-     * Use `listen` instead if you want to initialize the server without blocking the event loop
-     * @warning All routes defined with decorators are defined on this method just before the server starts listening for requests
+     * The description of the flag.
      */
-    waitUntilListening: () => Promise<void>;
+    description?: string;
     /**
-     * @alias disconnect
+     * The type of the flag.
      */
-    close: () => Promise<void>;
+    type: T;
     /**
-     * Closes the server and frees the port
+     * The name of the flag.
+     * @default The name of the field.
      */
-    disconnect: () => Promise<void>;
+    name?: string;
     /**
-     * Configure hash settings for password hashing
-     * @param options - Hash configuration options
-     * @param options.iterations - Number of PBKDF2 iterations (default: 600,000)
-     * @param options.saltLength - Salt length in bytes (default: 16)
-     * @param options.keyLength - Key length in bits (default: 256)
+     * The aliases of the flag.
      */
-    configureHash: (options: {
-        iterations?: number;
-        saltLength?: number;
-        keyLength?: number;
-    }) => void;
+    aliases?: string[] | string;
     /**
-     * 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
+     * The default value of the flag.
      */
-    getMockServer: () => Promise<MockServer>;
+    defaultValue?: InferFlagType<T>;
     /**
-     * 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
-     * ```
+     * Whether the flag is required.
+     * @default false
      */
-    exit: (code?: number) => void;
-}
-type StandardMethodOptions = {
-    middlewares?: ServerRouteMiddleware[] | ServerRouteMiddleware;
-    swagger?: SwaggerRouteOptions;
+    required?: boolean;
+    /**
+     * A function to parse the flag value.
+     * @default The value is returned as is.
+     */
+    parse?: (value: any) => InferFlagType<T>;
 };
-type SignalEvent = Deno.Signal | NodeJS.Signals;
 
-type RunTimeType = "bun" | "node" | "deno";
+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 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, res: Response$1, next: NextFunction) => SyncOrAsync;
-type ServerRouteHandler = (req: Request, 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
+ * 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"
  */
-type CustomBunFetch = (req: Request, server: Bun.Server<any>) => SyncOrAsync;
+declare const controller: (path?: string, swaggerOptions?: SwaggerRouteOptions) => (target: any) => void;
+
+type DelHandler = (req: Request, res: Response$1, ...args: any[]) => any;
 /**
- * Custom deno fetch call to be used as an hook inside Deno.serve method
+ * 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) {
+ *     // ...
+ *   }
+ * }
+ * ```
  */
-type CustomDenoFetch = (...options: Parameters<Parameters<typeof Deno.serve>[0]["handler"]>) => SyncOrAsync<Response | void>;
+declare const del: (path: string, options?: SwaggerRouteOptions) => <T extends DelHandler>(target: any, propertyKey: string, descriptor: PropertyDescriptor) => TypedPropertyDescriptor<T>;
+
+type GetHandler = (req: Request, res: Response$1, ...args: any[]) => any;
 /**
- * The options for the server tap function, allows you to interact with the server behavior before it is used to listen for incoming requests
+ * 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) {
+ *     // ...
+ *   }
+ * }
+ * ```
  */
-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;
-};
+declare const get: (path: string, options?: SwaggerRouteOptions) => <T extends GetHandler>(target: any, propertyKey: string, descriptor: PropertyDescriptor) => TypedPropertyDescriptor<T>;
+
+type PatchHandler = (req: Request, 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, 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, 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>;
 
 /**
  * Decorator to mark a middleware for a route or a controller class
@@ -3278,4 +3364,4 @@ declare const createPolicyDecorator: <T extends Record<string, PolicyProvider>>(
  */
 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, CustomTypedQueue, 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 PolicyDecorator, PolicyManager, type PolicyMetadata, type PolicyProvider, QueueManager, QueueService, Request, type RequestSchema, 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 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, TypedQueue, VALIDATION_ERROR_SYMBOL, type ValidatedData, type ValidationOptions, arg, asyncLocalStorage, asyncStorage, baseCommands, bullmqQueue, commandRegistry, compression, controller, cookie, cors, createExpressAdapter, createPolicyDecorator, createQueue, cron, defineLoggerConfig, defineQueueConfiguration, del, expressHandler, expressMiddleware, flag, get, getContentType, hash, helmet, log, logger, methodOverride, middleware, mountExpressRouter, mqtt, patch, pgbossQueue, post, put, rateLimiter, router, serialize, serveStatic, session, setCronGlobalErrorHandler, setMqttGlobalErrorHandler, sqsQueue, timeout, trustProxy, validate };
+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, CustomTypedQueue, 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 PolicyDecorator, PolicyManager, type PolicyMetadata, type PolicyProvider, QueueManager, QueueService, Request, type RequestSchema, 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 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, TypedQueue, VALIDATION_ERROR_SYMBOL, type ValidatedData, type ValidationOptions, arg, asyncLocalStorage, asyncStorage, baseCommands, bullmqQueue, commandRegistry, compression, controller, cookie, cors, createExpressAdapter, createPolicyDecorator, createQueue, cron, Server as default, defineLoggerConfig, defineQueueConfiguration, del, expressHandler, expressMiddleware, flag, get, getContentType, hash, helmet, log, logger, methodOverride, middleware, mountExpressRouter, mqtt, patch, pgbossQueue, post, put, rateLimiter, router, serialize, serveStatic, session, setCronGlobalErrorHandler, setMqttGlobalErrorHandler, sqsQueue, timeout, trustProxy, validate };