balda 0.0.21 → 0.0.22

package/lib/index.d.ts

@@ -1,4049 +0,0 @@
-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 { ApolloServerOptions, BaseContext } from '@apollo/server';
-import { DocumentNode, GraphQLResolveInfo } from 'graphql';
-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 { Ajv } from 'ajv';
-import { ZodType, z, ZodAny } 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';
-import { SendOptions } from 'pg-boss';
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { S3Client } from '@aws-sdk/client-s3';
-import { Transporter } from 'nodemailer';
-
-type GraphQLTypeDef = string | DocumentNode | string[] | DocumentNode[] | (() => string | DocumentNode | string[] | DocumentNode[]);
-type GraphQLResolvers = Record<string, unknown> | Record<string, unknown>[] | unknown;
-interface GraphQLContext extends BaseContext {
-}
-type GraphQLResolverFunction<TContext = GraphQLContext> = (parent: unknown, args: Record<string, unknown>, context: TContext, info: GraphQLResolveInfo) => unknown | Promise<unknown>;
-type GraphQLResolverMap<TContext = GraphQLContext> = Record<string, GraphQLResolverFunction<TContext> | Record<string, unknown>>;
-type GraphQLSchemaInput = {
-    typeDefs: GraphQLTypeDef;
-    resolvers?: GraphQLResolvers;
-};
-type GraphQLOptions = {
-    schema?: GraphQLSchemaInput;
-    apolloOptions?: Omit<ApolloServerOptions<GraphQLContext>, "typeDefs" | "resolvers"> & {
-        context?: ((arg: any) => GraphQLContext | Promise<GraphQLContext>) | GraphQLContext;
-    };
-};
-type GraphQLResolverType = "Query" | "Mutation" | "Subscription";
-
-declare class GraphQL {
-    private schemaOptions;
-    private apolloOptions;
-    isEnabled: boolean;
-    constructor(options?: GraphQLOptions);
-    getSchemaOptions(): GraphQLSchemaInput;
-    getApolloOptions(): Omit<ApolloServerOptions<GraphQLContext>, "typeDefs" | "resolvers">;
-    /**
-     * 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 resolveApolloOptions;
-    private addResolverByType;
-    private ensureResolversInitialized;
-    private mergeResolverIntoObject;
-    private addFullResolver;
-    private addResolverArray;
-    private addResolverObject;
-    private addTypeDefArray;
-    private ensureTypeDefsArray;
-}
-
-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 schema to validate the request body against (Zod, TypeBox, or plain JSON schema)
-     */
-    body?: RequestSchema;
-    /**
-     * 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
-     */
-    safe?: boolean;
-}
-
-type StaticPluginOptions = {
-    /**
-     * The file system directory path where the assets are located
-     * @example "./tmp/assets" or "public"
-     */
-    source: string;
-    /**
-     * The URL path where the assets will be served
-     * @example "/assets" or "/public"
-     */
-    path: string;
-};
-type FileAllowedMimeType = "text/html" | "text/css" | "application/javascript" | "application/typescript" | "text/jsx" | "text/tsx" | "application/json" | "application/xml" | "application/yaml" | "text/csv" | "text/plain" | "text/markdown" | "image/png" | "image/jpeg" | "image/gif" | "image/svg+xml" | "image/x-icon" | "image/webp" | "image/avif" | "image/bmp" | "image/tiff" | "image/heic" | "image/heif" | "video/mp4" | "video/webm" | "video/x-msvideo" | "video/quicktime" | "video/x-matroska" | "video/x-ms-wmv" | "video/x-flv" | "video/x-m4v" | "video/mpeg" | "video/3gpp" | "audio/mpeg" | "audio/wav" | "audio/ogg" | "audio/flac" | "audio/aac" | "audio/mp4" | "audio/x-ms-wma" | "audio/opus" | "audio/midi" | "font/woff" | "font/woff2" | "font/ttf" | "font/otf" | "application/vnd.ms-fontobject" | "application/pdf" | "application/msword" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.ms-excel" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/vnd.ms-powerpoint" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/vnd.oasis.opendocument.text" | "application/vnd.oasis.opendocument.spreadsheet" | "application/vnd.oasis.opendocument.presentation" | "application/rtf" | "application/epub+zip" | "application/zip" | "application/x-tar" | "application/gzip" | "application/x-bzip2" | "application/x-xz" | "application/vnd.rar" | "application/x-7z-compressed" | "application/wasm" | "application/manifest+json" | "text/calendar" | "text/vcard" | "application/sql" | "application/x-sh" | "application/x-msdos-program" | "application/x-msdownload" | "application/octet-stream" | "application/x-iso9660-image" | "application/x-apple-diskimage" | "application/vnd.android.package-archive" | "application/java-archive" | "application/x-shockwave-flash";
-
-type FormFile = {
-    /**
-     * The name of the form field.
-     */
-    formName: string;
-    /**
-     * The mime type of the file. (e.g. "image/png")
-     */
-    mimeType: string;
-    /**
-     * The size of the file in bytes.
-     */
-    size: number;
-    /**
-     * The temporary path of the file. Will be deleted after the request is processed automatically even in error cases.
-     */
-    tmpPath: string;
-    /**
-     * The original filename (including extension) as sent by the client
-     * (e.g. "avatar.png", "document.txt").
-     */
-    originalName: string;
-};
-type FilePluginOptions = {
-    /**
-     * The maximum size of each file.
-     * Supports formats like "5mb", "100kb".
-     * Example: "10mb", "500kb"
-     * Default: 1mb
-     */
-    maxFileSize?: `${number}mb` | `${number}kb`;
-    /**
-     * The maximum number of files allowed in a single request.
-     */
-    maxFiles?: number;
-    /**
-     * Allowed MIME types for uploaded files.
-     * If specified, only files with these MIME types will be accepted.
-     * Example: ['image/jpeg', 'image/png', 'application/pdf']
-     */
-    allowedMimeTypes?: (FileAllowedMimeType | (string & {}))[];
-};
-
-/**
- * The request object with type-safe path parameters.
- * 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.
- *
- * @template Params - The path parameters type (automatically extracted from route)
- */
-declare class Request<Params extends Record<string, string> = any> {
-    #private;
-    /**
-     * 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.
-     */
-    static fromRequest(request: globalThis.Request): Request;
-    /**
-     * 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
-     */
-    toWebApi(): globalThis.Request;
-    /**
-     * 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.
-     */
-    private static compileAndValidate;
-    /**
-     * The URL of the request
-     */
-    url: string;
-    /**
-     * The HTTP method of the request
-     */
-    method: string;
-    /**
-     * The headers of the request
-     */
-    headers: globalThis.Headers;
-    /**
-     * The signal for aborting the request
-     */
-    signal?: AbortSignal;
-    /**
-     * The referrer of the request
-     */
-    referrer?: string;
-    /**
-     * The referrer policy of the request
-     */
-    referrerPolicy?: ReferrerPolicy;
-    /**
-     * The mode of the request
-     */
-    mode?: RequestMode;
-    /**
-     * The credentials mode of the request
-     */
-    credentials?: RequestCredentials;
-    /**
-     * The cache mode of the request
-     */
-    cache?: RequestCache;
-    /**
-     * The redirect mode of the request
-     */
-    redirect?: RequestRedirect;
-    /**
-     * The integrity of the request
-     */
-    integrity?: string;
-    /**
-     * The keepalive flag of the request
-     */
-    keepalive?: boolean;
-    /**
-     * The parsed body of the request from the body parser middleware.
-     * If body parser middleware is not used, this will be undefined.
-     *
-     * Note: This is untyped - use validation decorators to get typed body as a handler argument.
-     */
-    body: any;
-    /**
-     * Flag indicating if the body has been read/parsed
-     */
-    bodyUsed: boolean;
-    /**
-     * The context of the request. Can be augmented extending AsyncLocalStorageContext interface
-     * @asyncLocalStorage middleware is required
-     * @example
-     * ```ts
-     * declare module "balda" {
-     *   interface AsyncLocalStorageContext {
-     *     userId: string;
-     *   }
-     * }
-     * ```
-     */
-    ctx: AsyncLocalStorageContext;
-    /**
-     * The file of the request.
-     * @fileParser middleware is required
-     */
-    file: (fieldName: string) => FormFile | null;
-    /**
-     * The cookies of the request.
-     * @cookie middleware is required
-     */
-    cookies: Record<string, string>;
-    /**
-     * The cookie of the request.
-     * @cookie middleware is required
-     */
-    cookie: (name: string) => string | undefined;
-    /**
-     * tells if the request has timed out.
-     * @timeout middleware is required
-     */
-    timeout?: boolean;
-    /**
-     * The session of the request. Uses cookies to send the session id
-     * @cookie middleware is required
-     * @session middleware is required
-     */
-    session?: Record<string, any>;
-    /**
-     * The session of the request. Uses cookies to send the session id
-     * @cookie middleware is required
-     * @session middleware is required
-     */
-    saveSession: () => Promise<void>;
-    /**
-     * The session of the request.
-     * @cookie middleware is required
-     * @session middleware is required
-     */
-    destroySession: () => Promise<void>;
-    /**
-     * The ip address of the request.
-     * Tries to get the ip address from the `x-forwarded-for` header. If not available, it will use the remote address from the request.
-     */
-    ip?: string;
-    /**
-     * The files of the request. Only available for multipart/form-data requests and if the file parser middleware is used.
-     */
-    files: FormFile[];
-    /**
-     * The parameters of the request. Can be typed with a generic in the Request object
-     * @example
-     * ```ts
-     * Request<{ id: string }>
-     */
-    params: Params;
-    /**
-     * The query parameters of the request.
-     * Lazy parsed - only parses URLSearchParams when accessed
-     *
-     * Note: This is untyped - use validation decorators to get typed query as a handler argument.
-     */
-    get query(): Record<string, string>;
-    set query(value: Record<string, string>);
-    /**
-     * Set the raw query string (called by server implementations)
-     * @internal
-     */
-    setQueryString(queryString: string): void;
-    /**
-     * The id of the request.
-     */
-    get id(): string;
-    set id(value: string);
-    /**
-     * The validated body of the request.
-     * @param inputSchema - The schema to validate the body against (Zod schema or JSON Schema).
-     * @param safe - If true, the function will return the original body if the validation fails instead of throwing an error.
-     */
-    validate<T extends RequestSchema>(inputSchema: T, safe?: boolean): ValidatedData<T>;
-    /**
-     * Validates the query string of the request.
-     * @param inputSchema - The schema to validate the query against (Zod schema or JSON Schema).
-     * @param safe - If true, the function will return undefined if the validation fails instead of throwing an error.
-     */
-    validateQuery<T extends RequestSchema>(inputSchema: T, safe?: boolean): ValidatedData<T>;
-    /**
-     * Validates the body and query string of the request.
-     * @param inputSchema - The schema to validate against (Zod schema or JSON Schema).
-     * @param safe - If true, the function will return undefined if the validation fails instead of throwing an error.
-     */
-    validateAll<T extends RequestSchema>(inputSchema: T, safe?: boolean): ValidatedData<T>;
-}
-
-interface AsyncLocalStorageContext {
-}
-type AsyncLocalStorageContextSetters<K extends keyof AsyncLocalStorageContext = keyof AsyncLocalStorageContext> = Record<K, (req: Request) => SyncOrAsync<AsyncLocalStorageContext[K]>>;
-
-interface JsonOptions {
-    /**
-     * The maximum size of the JSON body in bytes.
-     * If the body is larger than this limit, the request will be rejected.
-     * Default: 100kb
-     */
-    sizeLimit?: `${number}mb` | `${number}kb`;
-    /**
-     * If true, the JSON body will be parsed as an empty object if it is empty.
-     * Default: false (body will be undefined)
-     */
-    parseEmptyBodyAsObject?: boolean;
-    /**
-     * The custom error message to return when the JSON body is too large.
-     * Default: response with status 413 and body { message: "ERR_REQUEST_BODY_TOO_LARGE" }
-     */
-    customErrorMessage?: {
-        status?: number;
-        message?: string;
-    };
-}
-
-/**
- * Options for URL-encoded middleware
- */
-type UrlEncodedOptions = {
-    /**
-     * The maximum size of the URL-encoded body.
-     * Supports formats like "5mb", "100kb".
-     * Defaults to "1mb".
-     */
-    limit?: `${number}mb` | `${number}kb`;
-    /**
-     * Whether to parse extended syntax (objects and arrays). Defaults to false.
-     */
-    extended?: boolean;
-    /**
-     * The character encoding to use when parsing. Defaults to 'utf8'.
-     */
-    charset?: string;
-    /**
-     * Whether to allow empty values. Defaults to true.
-     */
-    allowEmpty?: boolean;
-    /**
-     * Maximum number of parameters to parse. Defaults to 1000.
-     */
-    parameterLimit?: number;
-};
-
-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;
-    /**
-     * Whether the cookie is secure (HTTPS only)
-     * @default true
-     *
-     * ⚠️ Should be `true` in production to prevent transmission over HTTP
-     */
-    secure?: boolean;
-    /**
-     * Whether the cookie is HTTP only (prevents JavaScript access)
-     * @default true
-     *
-     * ✅ Recommended: `true` to prevent XSS attacks
-     */
-    httpOnly?: boolean;
-    /**
-     * SameSite attribute for the cookie
-     *
-     * - "Strict": Most secure, cookie not sent on cross-site requests
-     * - "Lax": Balanced, cookie sent on top-level navigation
-     * - "None": Least secure, requires secure=true
-     *
-     * ✅ Recommended: "Strict" for auth cookies
-     */
-    sameSite?: "Strict" | "Lax" | "None";
-    /**
-     * Whether the cookie should be signed
-     */
-    signed?: boolean;
-    /**
-     * Priority for the cookie
-     */
-    priority?: "Low" | "Medium" | "High";
-};
-/**
- * Options for the cookie middleware
- */
-type CookieMiddlewareOptions = {
-    /**
-     * Secret key for signing cookies (required if using signed cookies)
-     */
-    secret?: string;
-    /**
-     * Default options for all cookies set by this middleware
-     */
-    defaults?: CookieOptions;
-    /**
-     * Whether to enable cookie parsing (defaults to true)
-     */
-    parse?: boolean;
-    /**
-     * Whether to enable cookie signing (defaults to false)
-     */
-    sign?: boolean;
-};
-
-type CorsMethods = "GET" | "POST" | "PUT" | "DELETE" | "OPTIONS" | "PATCH" | "HEAD";
-/**
- * Options for CORS middleware, similar to Express.js
- */
-type CorsOptions = {
-    /**
-     * Configures the Access-Control-Allow-Origin CORS header.
-     *
-     * ⚠️ WARNING: The default value '*' allows ALL origins, which is insecure for production.
-     *
-     * For production, explicitly set allowed origins:
-     * - Single origin: 'https://example.com'
-     * - Multiple origins: ['https://example.com', 'https://app.example.com']
-     * - Pattern matching: /^https:\/\/.*\.example\.com$/
-     *
-     * Defaults to '*' (allows all origins) - only suitable for development/public APIs.
-     */
-    origin?: string | RegExp | (string | RegExp)[];
-    /**
-     * Configures the Access-Control-Allow-Methods CORS header. Defaults to 'GET,HEAD,PUT,PATCH,POST,DELETE'.
-     */
-    methods?: CorsMethods[] | string;
-    /**
-     * Configures the Access-Control-Allow-Headers CORS header. Defaults to allowing all requested headers.
-     */
-    allowedHeaders?: string[] | string;
-    /**
-     * Configures the Access-Control-Expose-Headers CORS header. Defaults to none.
-     */
-    exposedHeaders?: string[] | string;
-    /**
-     * Configures the Access-Control-Allow-Credentials CORS header. Defaults to false.
-     */
-    credentials?: boolean;
-    /**
-     * Configures the Access-Control-Max-Age CORS header. Defaults to undefined (not sent).
-     */
-    maxAge?: number;
-    /**
-     * Pass the CORS preflight response to the next handler. Defaults to false (ends response).
-     */
-    preflightContinue?: boolean;
-    /**
-     * Provides a status code to use for successful OPTIONS requests, if preflightContinue is false. Defaults to 204.
-     */
-    optionsSuccessStatus?: number;
-};
-
-type ExpressHandler = RequestHandler;
-type ExpressRouter = IRouter;
-interface ExpressAdapterOptions {
-    basePath?: string;
-}
-
-/**
- * Options for helmet middleware
- */
-interface HelmetOptions {
-    dnsPrefetchControl?: boolean;
-    frameguard?: boolean | {
-        action: "DENY" | "SAMEORIGIN" | string;
-    };
-    hsts?: boolean | {
-        maxAge?: number;
-        includeSubDomains?: boolean;
-        preload?: boolean;
-    };
-    contentTypeOptions?: boolean;
-    ieNoOpen?: boolean;
-    xssFilter?: boolean;
-    referrerPolicy?: false | string;
-    crossOriginResourcePolicy?: false | string;
-    crossOriginOpenerPolicy?: false | string;
-    crossOriginEmbedderPolicy?: false | string;
-    contentSecurityPolicy?: false | string;
-}
-
-type LoggerOptions = Parameters<typeof pino$1>[0];
-
-interface LogOptions {
-    /**
-     * Whether to log the request.
-     * @default true
-     */
-    logRequest?: boolean;
-    /**
-     * What to log for the request.
-     * @default true for all properties
-     */
-    requestPayload?: {
-        method?: boolean;
-        url?: boolean;
-        ip?: boolean;
-        headers?: boolean;
-        /** Only json objects and strings are logged */
-        body?: boolean;
-    };
-    /**
-     * Whether to log the response.
-     * @default true
-     */
-    logResponse?: boolean;
-    /**
-     * Whether to log the response body.
-     * @default false
-     */
-    responsePayload?: {
-        status?: boolean;
-        headers?: boolean;
-        body?: boolean;
-    };
-    /**
-     * What to log for the response.
-     * @default true for all properties
-     */
-    pinoOptions?: LoggerOptions;
-}
-
-type MethodOverrideOptions = {
-    /**
-     * HTTP methods that can be overridden
-     * Default: ['POST']
-     */
-    methods?: string[];
-    /**
-     * Header name to read the override method from
-     * Default: 'X-HTTP-Method-Override'
-     */
-    header?: string;
-};
-
-type StorageStrategy = "memory" | "custom";
-type BaseRateLimiterOptions = {
-    /**
-     * The number of requests per window
-     * @default 100
-     */
-    limit?: number;
-    /**
-     * The message to return when the rate limit is exceeded
-     * @default "ERR_RATE_LIMIT_EXCEEDED"
-     */
-    message?: string;
-    /**
-     * The status code to return when the rate limit is exceeded
-     * @default 429
-     */
-    statusCode?: number;
-    /**
-     * The storage strategy to use
-     * @default "memory"
-     */
-    storageStrategy?: StorageStrategy;
-};
-/**
- * Key Strategy
- */
-type IpRateLimiterOptions = {
-    /**
-     * The type of rate limiter
-     */
-    type: "ip";
-} & BaseRateLimiterOptions;
-type CustomRateLimiterOptions = {
-    /**
-     * The type of rate limiter
-     */
-    type: "custom";
-    /**
-     * Generate a key for the rate limiter from the request (e.g. user id, email, etc.)
-     */
-    key: (req: Request) => string;
-    /**
-     * The storage strategy to use
-     * @default "memory"
-     */
-    storageStrategy?: StorageStrategy;
-} & BaseRateLimiterOptions;
-/**
- * Memory Storage Strategy
- */
-type MemoryStorageStrategy = {
-    /**
-     * The type of storage strategy
-     */
-    type: "memory";
-    /**
-     * The window in milliseconds
-     * @default 60000
-     */
-    windowMs?: number;
-};
-/**
- * Custom Storage Strategy
- */
-type CustomStorageStrategy = {
-    /**
-     * The type of storage strategy
-     */
-    type: "custom";
-    /**
-     * Set a value in the storage
-     */
-    set: (key: string, value: any) => Promise<void>;
-    /**
-     * Get a value from the storage
-     */
-    get: (key: string) => Promise<any>;
-};
-type StorageOptions$1 = MemoryStorageStrategy | CustomStorageStrategy;
-/**
- * Rate limiter options
- */
-type RateLimiterKeyOptions = IpRateLimiterOptions | CustomRateLimiterOptions;
-
-type SessionStore = {
-    get: (sid: string) => Promise<Record<string, any> | undefined>;
-    set: (sid: string, value: Record<string, any>, ttlSeconds?: number) => Promise<void>;
-    destroy: (sid: string) => Promise<void>;
-};
-type SessionOptions = {
-    /** Cookie name used for session id */
-    name?: string;
-    /** Secret used to sign session id (optional, for future) */
-    secret?: string;
-    /** TTL seconds for session */
-    ttl?: number;
-    /** Custom store, default is in-memory */
-    store?: SessionStore;
-    /** Whether to set HttpOnly secure flags */
-    cookie?: {
-        path?: string;
-        httpOnly?: boolean;
-        secure?: boolean;
-        sameSite?: "Strict" | "Lax" | "None";
-        domain?: string;
-    };
-};
-
-/**
- * Type of Swagger UI to use
- */
-type SwaggerUIType = "standard" | "rapidoc" | "scalar" | "elements" | "custom";
-type HTMLString = string;
-/**
- * Custom UI generator function that takes the spec URL and global options and returns HTML
- */
-type CustomUIGenerator = (specUrl: string, globalOptions: SwaggerGlobalOptions) => HTMLString;
-/**
- * Type of request body for a route
- */
-type SwaggerBodyType = "json" | "form-data" | "urlencoded";
-/**
- * JSONSchema type for OpenAPI/AJV-compatible schemas
- */
-type JSONSchema = {
-    $id?: string;
-    $schema?: string;
-    type?: string | string[];
-    properties?: Record<string, JSONSchema>;
-    items?: JSONSchema | JSONSchema[];
-    required?: string[];
-    enum?: any[];
-    allOf?: JSONSchema[];
-    oneOf?: JSONSchema[];
-    anyOf?: JSONSchema[];
-    not?: JSONSchema;
-    additionalProperties?: boolean | JSONSchema;
-    description?: string;
-    format?: string;
-    default?: any;
-    title?: string;
-    definitions?: Record<string, JSONSchema>;
-    [key: string]: any;
-};
-/**
- * Base options shared across all Swagger UI types
- */
-type SwaggerGlobalOptionsBase = {
-    /** The path to the swagger documentation, defaults to /docs for the UI and /docs/json for the raw json */
-    path?: string;
-    /** API title */
-    title?: string;
-    /** API description */
-    description?: string;
-    /** API version */
-    version?: string;
-    /** Server URLs */
-    servers?: string[];
-    /** Components (schemas, responses, parameters, etc.) */
-    components?: Record<string, any>;
-    /** Security schemes (OpenAPI 3.0 style) */
-    securitySchemes?: Record<string, Security>;
-    /** OpenID Connect configuration (discovery document) */
-    openIdConnect?: OpenIDConnectConfig;
-    /** API tags */
-    tags?: Record<string, any>;
-    /** Global security requirements */
-    security?: Security[];
-    /** External documentation */
-    externalDocs?: {
-        description?: string;
-        url: string;
-    };
-    /** Info object (detailed metadata) */
-    info?: {
-        title: string;
-        description?: string;
-        version: string;
-        termsOfService?: string;
-        contact?: {
-            name?: string;
-            url?: string;
-            email?: string;
-        };
-        license?: {
-            name: string;
-            url?: string;
-        };
-    };
-    /**
-     * OpenAPI models to be shown in the documentation. Must be valid OpenAPI/AJV JSONSchema objects.
-     */
-    models?: Record<string, JSONSchema> | JSONSchema[];
-};
-/**
- * Global documentation options for the API (OpenAPI/Swagger style)
- */
-type SwaggerGlobalOptions = (SwaggerGlobalOptionsBase & {
-    /** Type of Swagger UI to use, one of 'standard', 'redoc', 'rapidoc', 'scalar', or 'elements'. Defaults to 'standard'. */
-    type?: Exclude<SwaggerUIType, "custom">;
-}) | (SwaggerGlobalOptionsBase & {
-    /** Type of Swagger UI to use. When set to 'custom', customUIGenerator is required. */
-    type: "custom";
-    /** Custom UI generator function. Required when type is 'custom'. Must return a string of HTML that uses the given specUrl. */
-    customUIGenerator: CustomUIGenerator;
-});
-/**
- * Route-specific documentation options (for individual endpoints)
- */
-type SwaggerRouteOptions = {
-    /** Service category where the route belongs to */
-    service?: string;
-    /** Name of the route */
-    name?: string;
-    /** Query parameters schema */
-    query?: ZodType;
-    /** Request body schema */
-    requestBody?: ZodType;
-    /** Responses for this route */
-    responses?: Record<number, ZodType>;
-    /** Errors for this route */
-    errors?: Record<number, ZodType>;
-    /** Security requirements for this route */
-    security?: Security[] | Security;
-    /** Description of the route */
-    description?: string;
-    /** Deprecated flag */
-    deprecated?: boolean;
-    /** Exclude from swagger */
-    excludeFromSwagger?: boolean;
-    /**
-     * The request body type for this route. Allowed values: 'json', 'form-data', 'urlencoded'. Defaults to 'json'.
-     */
-    bodyType?: SwaggerBodyType;
-};
-type OAuth2Flows = {
-    implicit?: OAuth2Flow;
-    authorizationCode?: OAuth2Flow;
-    clientCredentials?: OAuth2Flow;
-    password?: OAuth2Flow;
-};
-type OAuth2Flow = {
-    authorizationUrl?: string;
-    tokenUrl?: string;
-    refreshUrl?: string;
-    scopes: Record<string, string>;
-};
-type OpenIDConnectConfig = {
-    issuer: string;
-    authorizationEndpoint: string;
-    tokenEndpoint: string;
-    userinfoEndpoint?: string;
-    jwksUri: string;
-    endSessionEndpoint?: string;
-    introspectionEndpoint?: string;
-    revocationEndpoint?: string;
-    scopesSupported?: string[];
-    responseTypesSupported?: string[];
-    grantTypesSupported?: string[];
-    tokenEndpointAuthMethodsSupported?: string[];
-    subjectTypesSupported?: string[];
-    idTokenSigningAlgValuesSupported?: string[];
-    claimsSupported?: string[];
-    codeChallengeMethodsSupported?: string[];
-};
-type Security = BearerOptions | ApiKeyOptions | OAuth2Options | OpenIdConnectOptions;
-type BearerOptions = {
-    type: "bearer";
-    bearerFormat?: string;
-    description?: string;
-};
-type ApiKeyOptions = {
-    type: "apiKey";
-    name: string;
-    in: "header" | "query" | "cookie";
-    description?: string;
-};
-type OAuth2Options = {
-    type: "oauth2";
-    flows: OAuth2Flows;
-    description?: string;
-    name?: string;
-};
-type OpenIdConnectOptions = {
-    type: "openIdConnect";
-    openIdConnectUrl: string;
-    description?: string;
-    name?: string;
-};
-
-/**
- * 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;
-
-/**
- * The response object with optional type-safe response body.
- * 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.
- * @template TBody - The expected response body type (for type safety)
- */
-declare class Response$1<TBody = any> {
-    static toWebResponse(response: Response$1): globalThis.Response;
-    /**
-     * The node http response object available only on the node runtime, useful for direct response manipulation
-     * @warning undefined on other runtimes since they already use Web API Response object
-     */
-    nodeResponse: ServerResponse;
-    /**
-     * The status of the response
-     */
-    responseStatus: number;
-    /**
-     * The headers of the response
-     */
-    headers: Record<string, string>;
-    /**
-     * The body of the response
-     */
-    private body;
-    constructor(status?: number);
-    /**
-     * Set a header for the response
-     */
-    setHeader(key: string, value: string): this;
-    /**
-     * Set the status of the response, status defaults to 200
-     */
-    status(status: number): this;
-    /**
-     * Send a response with the given body, tries to determine the content type based on the body type, status defaults to 200
-     * @warning If cannot determine the content type, it will be sent as is
-     */
-    send(body: TBody): void;
-    /**
-     * Send a response with the given body without any content type or encoding (as is), status defaults to 200
-     */
-    raw(body: any): void;
-    /**
-     * Send a response with the given text, status defaults to 200
-     */
-    text(body: string): void;
-    /**
-     * Send a response with the given JSON, status defaults to 200
-     */
-    json(body: TBody extends Record<string, unknown> | Array<unknown> ? TBody : Record<string, unknown> | Array<unknown>): void;
-    /**
-     * Send a response with the given HTML, status defaults to 200
-     */
-    html(htmlString: string): void;
-    /**
-     * Send a response with the given XML, status defaults to 200
-     */
-    xml(body: string): void;
-    /**
-     * Send a response with the given binary with Content-Type of application/octet-stream header, status defaults to 200
-     */
-    download(body: Uint8Array | Buffer): void;
-    /**
-     * Send a response with the given file content, status defaults to 200
-     * @param options only affects node and bun environment
-     */
-    file(pathToFile: string, options?: {
-        encoding?: string;
-        flag?: string;
-    }): void;
-    /**
-     * 2XX Success
-     */
-    /**
-     * 200 OK
-     */
-    ok(body?: TBody): void;
-    /**
-     * 201 Created
-     */
-    created(body?: TBody): void;
-    /**
-     * 202 Accepted
-     */
-    accepted(body?: TBody): void;
-    /**
-     * 204 No Content
-     */
-    noContent(): void;
-    /**
-     * 206 Partial Content
-     */
-    partialContent(body?: TBody): void;
-    /**
-     * 3XX Redirection
-     */
-    /**
-     * 300 Multiple Choices
-     */
-    multipleChoices(url: string): void;
-    redirect(url: string): void;
-    /**
-     * 301 Moved Permanently
-     */
-    movedPermanently(url: string): void;
-    /**
-     * 302 Found (Temporary Redirect)
-     */
-    found(url: string): void;
-    /**
-     * 303 See Other
-     */
-    seeOther(url: string): void;
-    /**
-     * 304 Not Modified
-     */
-    notModified(): void;
-    /**
-     * 307 Temporary Redirect
-     */
-    temporaryRedirect(url: string): void;
-    /**
-     * 308 Permanent Redirect
-     */
-    permanentRedirect(url: string): void;
-    /**
-     * 4XX Client Errors
-     */
-    /**
-     * 400 Bad Request
-     */
-    badRequest(body?: TBody): void;
-    /**
-     * 401 Unauthorized
-     */
-    unauthorized(body?: TBody): void;
-    /**
-     * 403 Forbidden
-     */
-    forbidden(body?: TBody): void;
-    /**
-     * 404 Not Found
-     */
-    notFound(body?: TBody): void;
-    /**
-     * 405 Method Not Allowed
-     */
-    methodNotAllowed(body?: TBody): void;
-    /**
-     * 406 Not Acceptable
-     */
-    notAcceptable(body?: TBody): void;
-    /**
-     * 409 Conflict
-     */
-    conflict(body?: TBody): void;
-    /**
-     * 410 Gone
-     */
-    gone(body?: TBody): void;
-    /**
-     * 413 Payload Too Large
-     */
-    payloadTooLarge(body?: TBody): void;
-    /**
-     * 415 Unsupported Media Type
-     */
-    unsupportedMediaType(body?: TBody): void;
-    /**
-     * 422 Unprocessable Entity
-     */
-    unprocessableEntity(body?: TBody): void;
-    /**
-     * 429 Too Many Requests
-     */
-    tooManyRequests(body?: TBody): void;
-    /**
-     * 5XX Server Errors
-     */
-    internalServerError(body?: TBody): void;
-    /**
-     * 501 Not Implemented
-     */
-    notImplemented(body?: TBody): void;
-    /**
-     * 502 Bad Gateway
-     */
-    badGateway(body?: TBody): void;
-    /**
-     * 503 Service Unavailable
-     */
-    serviceUnavailable(body?: TBody): void;
-    /**
-     * 504 Gateway Timeout
-     */
-    gatewayTimeout(body?: TBody): void;
-    /**
-     * 505 HTTP Version Not Supported
-     */
-    httpVersionNotSupported(body?: TBody): void;
-    /**
-     * Set a cookie for the response, cookie middleware must be registered in order to use this function
-     */
-    cookie?(_name: string, _value: string, _options?: CookieOptions): void;
-    /**
-     * Clear a cookie for the response, cookie middleware must be registered in order to use this function
-     */
-    clearCookie?(_name: string, _options?: CookieOptions): void;
-    /**
-     * Stream a response using an async generator or ReadableStream
-     * Sets appropriate headers for Server-Sent Events by default
-     */
-    stream(source: AsyncGenerator<any> | Generator<any> | ReadableStream, options?: {
-        customHeaders?: Record<string, string>;
-    }): void;
-    /**
-     * Get the body of the response
-     */
-    getBody(): any;
-}
-
-/**
- * Extracts parameter names from a path string and creates a typed object
- * @example ExtractParams<"/users/:id/posts/:postId"> → { id: string; postId: string }
- */
-type ExtractParams<T extends string> = T extends `${infer _Start}:${infer Param}/${infer Rest}` ? {
-    [K in Param | keyof ExtractParams<Rest>]: string;
-} : T extends `${infer _Start}:${infer Param}` ? {
-    [K in Param]: string;
-} : Record<string, never>;
-/**
- * Helper type to infer the output type from a Zod schema, TypeBox schema, or any schema with _output
- */
-type InferSchemaType<T> = T extends ZodAny ? z.infer<T> : T extends TSchema ? Static<T> : T;
-
-/**
- * Singleton that handles the routing of requests to the appropriate handler(s).
- */
-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 with type-safe path parameters.
-     */
-    get<TPath extends string = string>(path: TPath, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>, swaggerOptions?: SwaggerRouteOptions): void;
-    get<TPath extends string = string>(path: TPath, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>, swaggerOptions?: SwaggerRouteOptions): void;
-    /**
-     * Register a POST route under this router's base path with type-safe path parameters.
-     */
-    post<TPath extends string = string>(path: TPath, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>, swaggerOptions?: SwaggerRouteOptions): void;
-    post<TPath extends string = string>(path: TPath, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>, swaggerOptions?: SwaggerRouteOptions): void;
-    /**
-     * Register a PATCH route under this router's base path with type-safe path parameters.
-     */
-    patch<TPath extends string = string>(path: TPath, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>, swaggerOptions?: SwaggerRouteOptions): void;
-    patch<TPath extends string = string>(path: TPath, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>, swaggerOptions?: SwaggerRouteOptions): void;
-    /**
-     * Register a PUT route under this router's base path with type-safe path parameters.
-     */
-    put<TPath extends string = string>(path: TPath, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>, swaggerOptions?: SwaggerRouteOptions): void;
-    put<TPath extends string = string>(path: TPath, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>, swaggerOptions?: SwaggerRouteOptions): void;
-    /**
-     * Register a DELETE route under this router's base path with type-safe path parameters.
-     */
-    delete<TPath extends string = string>(path: TPath, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>, swaggerOptions?: SwaggerRouteOptions): void;
-    delete<TPath extends string = string>(path: TPath, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>, swaggerOptions?: SwaggerRouteOptions): void;
-    /**
-     * Register an OPTIONS route under this router's base path with type-safe path parameters.
-     */
-    options<TPath extends string = string>(path: TPath, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>, swaggerOptions?: SwaggerRouteOptions): void;
-    options<TPath extends string = string>(path: TPath, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>, swaggerOptions?: SwaggerRouteOptions): void;
-    /**
-     * Register an HEAD route under this router's base path with type-safe path parameters.
-     */
-    head<TPath extends string = string>(path: TPath, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>, swaggerOptions?: SwaggerRouteOptions): void;
-    head<TPath extends string = string>(path: TPath, middleware: ServerRouteMiddleware | ServerRouteMiddleware[], handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>, swaggerOptions?: SwaggerRouteOptions): void;
-    /**
-     * Create a grouped router that shares a base path and middlewares.
-     * The callback receives a child router where routes are defined; routes
-     * are then merged back into the parent with the composed base path and middlewares.
-     */
-    group(path: string, middleware: ServerRouteMiddleware[] | ServerRouteMiddleware, cb: (router: Router) => void): void;
-    group(path: string, cb: (router: Router) => void): void;
-    /**
-     * Apply global middlewares to all routes
-     * @param middlewares - The middlewares to apply
-     * @internal
-     */
-    applyGlobalMiddlewaresToAllRoutes(middlewares: ServerRouteMiddleware[]): void;
-    private normalizeBasePath;
-    private joinPath;
-}
-
-type Params = Record<string, string>;
-interface Route {
-    method: string;
-    path: string;
-    middleware: ServerRouteMiddleware[];
-    handler: ServerRouteHandler;
-    swaggerOptions?: SwaggerRouteOptions;
-}
-/**
- * The client router is a subset of the router that is used to define routes on library level by the end user.
- */
-type ClientRouter = Omit<Router, "applyGlobalMiddlewaresToAllRoutes" | "addOrUpdate">;
-
-type ServerPlugin = {
-    bodyParser?: BodyParserOptions;
-    cors?: CorsOptions;
-    static?: StaticPluginOptions;
-    helmet?: HelmetOptions;
-    cookie?: CookieMiddlewareOptions;
-    log?: LogOptions;
-    rateLimiter?: {
-        keyOptions?: RateLimiterKeyOptions;
-        storageOptions?: StorageOptions$1;
-    };
-    trustProxy?: TrustProxyOptions;
-    timeout?: TimeoutOptions;
-    session?: SessionOptions;
-    methodOverride?: MethodOverrideOptions;
-    compression?: CompressionOptions;
-    asyncLocalStorage?: AsyncLocalStorageContextSetters;
-};
-type NodeHttpClient = "http" | "http2" | "https" | "http2-secure";
-type ServerOptions<H extends NodeHttpClient = NodeHttpClient> = {
-    /** Specific node client to use for nodejs, default to `http` */
-    nodeHttpClient?: H;
-    /** The port to listen on, uses the PORT env if present, defaults to 80 */
-    port?: number;
-    /** The hostname to listen on, uses the HOST env if present, defaults to 0.0.0.0 */
-    host?: string;
-    /** Controller patterns to match, defaults to an empty array */
-    controllerPatterns?: string[];
-    /** Basic plugins to apply to all requests, plugins are applied in order based on where they are defined in the `plugins` object, by default no plugins are applied */
-    plugins?: ServerPlugin;
-    /** The tap options to interact with the underlying server connector before it is used to listen for incoming requests */
-    tapOptions?: ServerTapOptions;
-    /**
-     * The swagger options to apply to the server, by default swagger plugin is applied with standard options, you can pass a boolean to enable or disable the plugin or you can pass an object to apply custom options to the plugin
-     * @example
-     * ```ts
-     * const server = new Server({
-     *   swagger: true,
-     * });
-     * ```
-     */
-    swagger?: Parameters<typeof swagger>[0] | boolean;
-    /**
-     * The graphql options to apply to the server, by default graphql plugin is not enabled, you can pass a boolean to enable or disable the plugin or you can pass an object to apply custom options to the plugin (when options are provided the plugin is always enabled)
-     * @example
-     * ```ts
-     * const server = new Server({
-     *   graphql: true,
-     * });
-     * ```
-     * @example
-     * ```ts
-     * const server = new Server({
-     *   graphql: {
-     *     schema: createSchema({ typeDefs: `type Query { hello: String }`, resolvers: { Query: { hello: () => 'Hello World' } } }),
-     *   },
-     * });
-     * ```
-     */
-    graphql?: GraphQLOptions;
-    /**
-     * 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({
-     *   ajvInstance: new Ajv(),
-     * });
-     * ```
-     */
-    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 = {
-    nodeHttpClient: NodeHttpClient;
-    port: number;
-    host: string;
-    controllerPatterns: string[];
-    plugins: ServerPlugin;
-    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 {
-    /**
-     * Identifier for the balda server instance
-     */
-    _brand: "BaldaServer";
-    /**
-     * Whether the server is in production mode NODE_ENV is set to "production"
-     */
-    isProduction: boolean;
-    /**
-     * Whether the server is listening for requests
-     */
-    isListening: boolean;
-    /**
-     * The url of the server
-     */
-    url: string;
-    /**
-     * The port of the server
-     */
-    port: number;
-    /**
-     * The host of the server
-     */
-    host: string;
-    /**
-     * Settings applied before server is listening, this is used to tap into the server connector for the current runtime and modify it before it is used to listen for incoming requests
-     * @warning Must be used before `listen` method
-     */
-    tapOptions?: ServerTapOptions;
-    /**
-     * Server options passed to the constructor
-     */
-    serverOptions: ResolvedServerOptions;
-    /**
-     * Main singleton router instance of the server
-     */
-    router: ClientRouter;
-    /**
-     * Hash the given data using the native hash function of the current runtime
-     * @param data - The data to hash
-     * @returns The hashed data
-     */
-    hash: (data: string) => Promise<string>;
-    /**
-     * Compare the given data with the given hash using the native hash function of the current runtime
-     * @param hash - The hash to compare the data with
-     * @param data - The data to compare with the hash
-     * @returns Whether the data matches the hash
-     */
-    compareHash: (hash: string, data: string) => Promise<boolean>;
-    /**
-     * Get the environment variables of the server using the native environment variables of the current runtime
-     */
-    getEnvironment: () => Record<string, string>;
-    /**
-     * The path to the temporary directory, you can append a path to the temporary directory to get a new path.
-     * It uses the current working directory of the runtime to get the base path.
-     * @example
-     * ```ts
-     * server.tmpPath("my-app"); // -> ${cwd}/tmp/my-app
-     * ```
-     */
-    tmpDir: (...append: string[]) => string;
-    /**
-     * Create a new directory
-     * @param path - The path to the directory
-     * @param options - The options to create the directory
-     * @param options.recursive - Whether to create the directory recursively
-     * @param options.mode - The mode of the directory
-     */
-    mkdir: (path: string, options?: {
-        recursive?: boolean;
-        mode?: number | string;
-    }) => Promise<void>;
-    /**
-     * Mount an Express middleware or router at a specific path for compatibility with Express-based libraries like AdminJS
-     * @param pathOrMiddleware - The path to mount at, or the Express middleware/router if mounting at root
-     * @param maybeMiddleware - The Express middleware or router when path is provided
-     */
-    useExpress: (pathOrMiddleware: string | RequestHandler | ExpressRouter, maybeMiddleware?: RequestHandler | ExpressRouter) => void;
-    /**
-     * Convert an Express middleware to a Balda-compatible middleware
-     * @param middleware - The Express middleware to convert
-     * @returns A Balda-compatible middleware
-     */
-    expressMiddleware: (middleware: RequestHandler) => ServerRouteMiddleware;
-    /**
-     * Mount an Express router at a specific base path
-     * @param basePath - The base path to mount the router at
-     * @param expressRouter - The Express router to mount
-     */
-    mountExpressRouter: (basePath: string, expressRouter: ExpressRouter) => void;
-    /**
-     * Shorthand for the server.router.get method
-     */
-    get: (...args: any[]) => void;
-    /**
-     * Shorthand for the server.router.post method
-     */
-    post: (...args: any[]) => void;
-    /**
-     * Shorthand for the server.router.put method
-     */
-    put: (...args: any[]) => void;
-    /**
-     * Shorthand for the server.router.patch method
-     */
-    patch: (...args: any[]) => void;
-    /**
-     * Shorthand for the server.router.delete method
-     */
-    delete: (...args: any[]) => void;
-    /**
-     * Shorthand for the server.router.options method
-     */
-    options: (...args: any[]) => void;
-    /**
-     * Shorthand for the server.router.head method
-     */
-    head: (...args: any[]) => void;
-    /**
-     * Shorthand for the server.router.group method
-     */
-    group: (...args: any[]) => void;
-    /**
-     * Get the node server instance, you must be using node runtime to use this method based on the nodeHttpClient option passed to the server constructor (defaults to http)
-     * @throws if the runtime is not node
-     */
-    getNodeServer: () => RuntimeServerMap<"node", NodeHttpClient>;
-    /**
-     * Get the bun server instance, you must be using bun runtime to use this method
-     * @throws if the runtime is not bun
-     */
-    getBunServer: () => RuntimeServerMap<"bun">;
-    /**
-     * Get the deno server instance, you must be using deno runtime to use this method
-     * @throws if the runtime is not deno
-     */
-    getDenoServer: () => RuntimeServerMap<"deno">;
-    /**
-     * Embed the given key into the server instance, this is useful for embedding the server with custom context inside the server instance, you can extend the server with your own properties to type it
-     * @param key - The key to embed
-     * @param value - The value to embed
-     * @warning There are some keys that are protected and cannot be embedded, you can find the list of protected keys in the PROTECTED_KEYS constant
-     * @throws An error if the key is already defined in the server instance or if the key is protected
-     * @example
-     * ```typescript
-     * // For better type safety, you can declare a module for the server interface
-     * declare module "balda" {
-     *   interface Server {
-     *     myCustomProperty: string;
-     *   }
-     * }
-     *
-     * server.embed("myCustomProperty", "myCustomValue");
-     * console.log(server.myCustomProperty); // Type safe if ServerInterface is extended
-     * ```
-     */
-    embed: (key: string, value: any) => void;
-    /**
-     * Register a signal event listener to the server, this is useful for handling signals like SIGINT, SIGTERM, etc.
-     * @param event - The signal event to listen for
-     * @param cb - The callback to be called when the signal event is received
-     */
-    on: (event: SignalEvent, cb: () => SyncOrAsync) => void;
-    /**
-     * Register a signal event listener to the server, this is useful for handling signals like SIGINT, SIGTERM, etc.
-     * @param event - The signal event to listen for
-     * @param cb - The callback to be called when the signal event is received
-     */
-    once: (event: SignalEvent, cb: () => SyncOrAsync) => void;
-    /**
-     * Register a global middleware to be applied to all routes after the listener is bound, the middleware is applied in the order it is registered
-     */
-    use: (middleware: ServerRouteMiddleware) => void;
-    /**
-     * Set the error handler for the server
-     * @param errorHandler - The error handler to be applied to all routes
-     */
-    setErrorHandler: (errorHandler?: ServerErrorHandler) => void;
-    /**
-     * 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;
-}
-
-/**
- * Type-safe options for the mock server
- * @template TBody - The request body type
- * @template TQuery - The query parameters type
- */
-interface MockServerOptions<TBody = any, TQuery extends Record<string, string> = any> {
-    /**
-     * The body of the request (typed)
-     */
-    body?: TBody;
-    /**
-     * The form data of the request
-     */
-    formData?: FormData;
-    /**
-     * The urlencoded body of the request
-     */
-    urlencoded?: Record<string, string>;
-    /**
-     * The headers of the request
-     */
-    headers?: Record<string, string>;
-    /**
-     * The query parameters of the request (typed)
-     */
-    query?: TQuery;
-    /**
-     * The cookies of the request
-     */
-    cookies?: Record<string, string>;
-    /**
-     * The ip of the request
-     */
-    ip?: string;
-}
-
-/**
- * Allows to mock server requests without needing to start the server, useful for testing purposes
- */
-declare class MockServer {
-    readonly server: Server<NodeHttpClient>;
-    private ensureGraphQLHandler;
-    constructor(server: Server<NodeHttpClient>);
-    /**
-     * Simulates an HTTP request without making an actual network call, useful for testing purposes
-     * Executes the middleware chain and handler of the route
-     * @param method - The HTTP method (GET, POST, PUT, DELETE, PATCH)
-     * @param path - The request path
-     * @param options - Request options including body, headers, query params, etc.
-     * @throws {Error} - If more than one of body, formData, urlencoded is provided
-     */
-    request<TResponse = any, TBody = any, TQuery extends Record<string, string> = any>(method: HttpMethod, path: string, options?: MockServerOptions<TBody, TQuery>): Promise<MockResponse<TResponse>>;
-    /**
-     * Type-safe GET request
-     * @template TResponse - The response body type
-     * @template TQuery - The query parameters type
-     * @example
-     * const res = await mock.get<UserResponse, { id: string }>("/users/123");
-     */
-    get<TResponse = any, TQuery extends Record<string, string> = any>(path: string, options?: Omit<MockServerOptions<never, TQuery>, "body" | "formData" | "urlencoded">): Promise<MockResponse<TResponse>>;
-    /**
-     * Type-safe POST request
-     * @template TResponse - The response body type
-     * @template TBody - The request body type
-     * @template TQuery - The query parameters type
-     * @example
-     * const res = await mock.post<UserResponse, CreateUserInput>("/users", { body: { name: "John" } });
-     */
-    post<TResponse = any, TBody = any, TQuery extends Record<string, string> = any>(path: string, options?: MockServerOptions<TBody, TQuery>): Promise<MockResponse<TResponse>>;
-    /**
-     * Type-safe PUT request
-     * @template TResponse - The response body type
-     * @template TBody - The request body type
-     * @template TQuery - The query parameters type
-     * @example
-     * const res = await mock.put<UserResponse, UpdateUserInput>("/users/123", { body: { name: "Jane" } });
-     */
-    put<TResponse = any, TBody = any, TQuery extends Record<string, string> = any>(path: string, options?: MockServerOptions<TBody, TQuery>): Promise<MockResponse<TResponse>>;
-    /**
-     * Type-safe PATCH request
-     * @template TResponse - The response body type
-     * @template TBody - The request body type
-     * @template TQuery - The query parameters type
-     * @example
-     * const res = await mock.patch<UserResponse, Partial<UpdateUserInput>>("/users/123", { body: { name: "Jane" } });
-     */
-    patch<TResponse = any, TBody = any, TQuery extends Record<string, string> = any>(path: string, options?: MockServerOptions<TBody, TQuery>): Promise<MockResponse<TResponse>>;
-    /**
-     * Type-safe DELETE request (no body allowed per HTTP spec)
-     * @template TResponse - The response body type
-     * @template TQuery - The query parameters type
-     * @example
-     * const res = await mock.delete<DeleteResponse>("/users/123");
-     */
-    delete<TResponse = any, TQuery extends Record<string, string> = any>(path: string, options?: Omit<MockServerOptions<never, TQuery>, "body" | "formData">): Promise<MockResponse<TResponse>>;
-    /**
-     * Converts FormData to a proper multipart/form-data body with boundaries
-     */
-    private formDataToMultipart;
-    private handleGraphQLRequest;
-    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;
-    /**
-     * 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
-     */
-    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<TPath extends string = string>(path: TPath, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>): void;
-    get<TPath extends string = string>(path: TPath, options: StandardMethodOptions, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>): void;
-    post<TPath extends string = string>(path: TPath, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>): void;
-    post<TPath extends string = string>(path: TPath, options: StandardMethodOptions, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>): void;
-    patch<TPath extends string = string>(path: TPath, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>): void;
-    patch<TPath extends string = string>(path: TPath, options: StandardMethodOptions, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>): void;
-    put<TPath extends string = string>(path: TPath, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>): void;
-    put<TPath extends string = string>(path: TPath, options: StandardMethodOptions, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>): void;
-    delete<TPath extends string = string>(path: TPath, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>): void;
-    delete<TPath extends string = string>(path: TPath, options: StandardMethodOptions, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>): void;
-    options<TPath extends string = string>(path: TPath, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>): void;
-    options<TPath extends string = string>(path: TPath, options: StandardMethodOptions, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>): void;
-    head<TPath extends string = string>(path: TPath, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>): void;
-    head<TPath extends string = string>(path: TPath, options: StandardMethodOptions, handler: (req: Request<ExtractParams<TPath>>, res: Response$1) => void | Promise<void>): 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>;
-    /**
-     * 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
-     */
-    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
-     * @returns A promise that resolves when the server is disconnected
-     */
-    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;
-    /**
-     * Initializes the server by importing the controllers and applying the plugins, it's idempotent, it will not re-import the controllers or apply the plugins if the server was already initialized (e.g. mockServer init)
-     * @internal
-     */
-    private bootstrap;
-    /**
-     * Handles not found routes by delegating to custom handler or default error response
-     * Checks if the path exists for other methods and returns 405 if so
-     * @internal
-     */
-    private handleNotFound;
-    /**
-     * Registers a not found route for all routes that are not defined
-     * @internal
-     */
-    private registerNotFoundRoutes;
-    /**
-     * Sets up the abort signal handler to gracefully shutdown the server when aborted
-     * @internal
-     */
-    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 = {
-    /**
-     * The description of the argument.
-     */
-    description?: string;
-    /**
-     * Whether the argument is required.
-     * @default false
-     */
-    required?: boolean;
-    /**
-     * The default value of the argument.
-     */
-    defaultValue?: string;
-    /**
-     * A function to parse the argument value.
-     * @default The value is returned as is.
-     */
-    parse?: (value: string) => string;
-};
-type FlagOptions<T extends FlagType> = {
-    /**
-     * The description of the flag.
-     */
-    description?: string;
-    /**
-     * The type of the flag.
-     */
-    type: T;
-    /**
-     * The name of the flag.
-     * @default The name of the field.
-     */
-    name?: string;
-    /**
-     * The aliases of the flag.
-     */
-    aliases?: string[] | string;
-    /**
-     * The default value of the flag.
-     */
-    defaultValue?: InferFlagType<T>;
-    /**
-     * Whether the flag is required.
-     * @default false
-     */
-    required?: boolean;
-    /**
-     * A function to parse the flag value.
-     * @default The value is returned as is.
-     */
-    parse?: (value: any) => InferFlagType<T>;
-};
-
-declare const VALIDATION_ERROR_SYMBOL = "VALIDATION_ERROR";
-declare const ARG_SYMBOL = "ARG";
-/**
- * Decorator to mark a field of a command class as an argument.
- * @param options - The options for the argument.
- * @warning Arguments are evaluated in the order they are defined in the Command class.
- */
-declare const arg: (options: ArgOptions) => (target: any, propertyKey: string) => void;
-
-declare const flag: {
-    <T extends FlagType>(options: FlagOptions<T>): (target: any, propertyKey: string) => void;
-    boolean(options: Omit<FlagOptions<"boolean">, "type">): (target: any, propertyKey: string) => void;
-    string(options: Omit<FlagOptions<"string">, "type">): (target: any, propertyKey: string) => void;
-    number(options: Omit<FlagOptions<"number">, "type">): (target: any, propertyKey: string) => void;
-    list(options: Omit<FlagOptions<"list">, "type">): (target: any, propertyKey: string) => void;
-    array(options: Omit<FlagOptions<"list">, "type">): (target: any, propertyKey: string) => void;
-};
-
-/**
- * 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;
-
-/**
- * Decorator to mark a handler for a DELETE request with type-safe path parameters and response body
- * DELETE requests cannot have a request body (by HTTP spec)
- * Query params must be validated with @validate decorators to be typed
- * @param path - The path of the route (path parameters will be automatically inferred)
- * @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";
- *
- * type DeletedResponse = { id: string; deleted: boolean };
- *
- * @controller("/api")
- * class MyController {
- *   @del("/:id")
- *   async handler(
- *     req: Request<{ id: string }>,
- *     res: Response<DeletedResponse>
- *   ) {
- *     const { id } = req.params; // ✅ id is typed as string!
- *     res.json({ id, deleted: true });
- *   }
- * }
- * ```
- */
-declare const del: <TPath extends string = string>(path: TPath, options?: SwaggerRouteOptions) => <T extends (req: Request<ExtractParams<TPath>>, res: Response$1, ...args: any[]) => any>(target: any, propertyKey: string, descriptor: PropertyDescriptor) => TypedPropertyDescriptor<T>;
-
-/**
- * Decorator to mark a handler for a GET request with type-safe path parameters and response body
- * GET requests cannot have a request body (by HTTP spec)
- * Body and query must be validated with @validate decorators to be typed
- * @param path - The path of the route (path parameters will be automatically inferred)
- * @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, validate, Request, Response } from "balda";
- * import { z } from "zod";
- *
- * const UserQuerySchema = z.object({ include: z.string().optional() });
- * type UserQuery = z.infer<typeof UserQuerySchema>;
- * type UserResponse = { id: string; name: string };
- *
- * @controller("/api")
- * class MyController {
- *   @get("/:id")
- *   @validate.query(UserQuerySchema)
- *   async handler(
- *     req: Request<{ id: string }>,
- *     res: Response<UserResponse>,
- *     query: UserQuery  // ✅ Validated and typed!
- *   ) {
- *     const { id } = req.params; // ✅ id is typed as string!
- *     const { include } = query; // ✅ query is validated and typed!
- *     res.json({ id, name: "John" });
- *   }
- * }
- * ```
- */
-declare const get: <TPath extends string = string>(path: TPath, options?: SwaggerRouteOptions) => <T extends (req: Request<ExtractParams<TPath>>, res: Response$1, ...args: any[]) => any>(target: any, propertyKey: string, descriptor: PropertyDescriptor) => TypedPropertyDescriptor<T>;
-
-/**
- * Decorator to mark a handler for a PATCH request with type-safe path parameters and response body
- * Body and query must be validated with @validate decorators to be typed
- * @param path - The path of the route (path parameters will be automatically inferred)
- * @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, validate, Request, Response } from "balda";
- * import { z } from "zod";
- *
- * const UpdateUserSchema = z.object({ name: z.string().optional() });
- * type UpdateUserInput = z.infer<typeof UpdateUserSchema>;
- * type UpdatedResponse = { id: string; updated: boolean };
- *
- * @controller("/api")
- * class MyController {
- *   @patch("/:id")
- *   @validate.body(UpdateUserSchema)
- *   async handler(
- *     req: Request<{ id: string }>,
- *     res: Response<UpdatedResponse>,
- *     body: UpdateUserInput  // ✅ Validated and typed!
- *   ) {
- *     const { id } = req.params; // ✅ id is typed as string!
- *     res.json({ id, updated: true });
- *   }
- * }
- * ```
- */
-declare const patch: <TPath extends string = string>(path: TPath, options?: SwaggerRouteOptions) => <T extends (req: Request<ExtractParams<TPath>>, res: Response$1, ...args: any[]) => any>(target: any, propertyKey: string, descriptor: PropertyDescriptor) => TypedPropertyDescriptor<T>;
-
-/**
- * Decorator to mark a handler for a POST request with type-safe path parameters and response body
- * Body and query must be validated with @validate decorators to be typed
- * @param path - The path of the route (path parameters will be automatically inferred)
- * @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, validate, Request, Response } from "balda";
- * import { z } from "zod";
- *
- * const CreateUserSchema = z.object({ name: z.string(), email: z.string().email() });
- * type CreateUserInput = z.infer<typeof CreateUserSchema>;
- * type CreatedResponse = { id: string; created: boolean };
- *
- * @controller("/api")
- * class MyController {
- *   @post("/")
- *   @validate.body(CreateUserSchema)
- *   async handler(
- *     req: Request<{}>,
- *     res: Response<CreatedResponse>,
- *     body: CreateUserInput  // ✅ Validated and typed!
- *   ) {
- *     const { name, email } = body; // ✅ body is validated and typed!
- *     res.json({ id: "123", created: true });
- *   }
- * }
- * ```
- */
-declare const post: <TPath extends string = string>(path: TPath, options?: SwaggerRouteOptions) => <T extends (req: Request<ExtractParams<TPath>>, res: Response$1, ...args: any[]) => any>(target: any, propertyKey: string, descriptor: PropertyDescriptor) => TypedPropertyDescriptor<T>;
-
-/**
- * Decorator to mark a handler for a PUT request with type-safe path parameters and response body
- * Body and query must be validated with @validate decorators to be typed
- * @param path - The path of the route (path parameters will be automatically inferred)
- * @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, validate, Request, Response } from "balda";
- * import { z } from "zod";
- *
- * const UpdateUserSchema = z.object({ name: z.string(), email: z.string().email() });
- * type UpdateUserInput = z.infer<typeof UpdateUserSchema>;
- * type UserResponse = { id: string; name: string };
- *
- * @controller("/api")
- * class MyController {
- *   @put("/:id")
- *   @validate.body(UpdateUserSchema)
- *   async handler(
- *     req: Request<{ id: string }>,
- *     res: Response<UserResponse>,
- *     body: UpdateUserInput  // ✅ Validated and typed!
- *   ) {
- *     const { id } = req.params; // ✅ id is typed as string!
- *     res.json({ id, name: body.name });
- *   }
- * }
- * ```
- */
-declare const put: <TPath extends string = string>(path: TPath, options?: SwaggerRouteOptions) => <T extends (req: Request<ExtractParams<TPath>>, res: Response$1, ...args: any[]) => any>(target: any, propertyKey: string, descriptor: PropertyDescriptor) => TypedPropertyDescriptor<T>;
-
-/**
- * Type-safe handler for routes with typed path parameters and response
- * Body and query are validated first and passed as separate typed arguments
- * @example
- * TypedHandler<"/users/:id", CreateUserSchema, SearchQuerySchema, UserResponse>
- *   → (req: Request<{ id: string }>, res: Response<UserResponse>, body: CreateUserInput, query: SearchQuery) => void | Promise<void>
- */
-type TypedHandler<TPath extends string, TBody extends RequestSchema | undefined = undefined, TQuery extends RequestSchema | undefined = undefined, TResponseBody = any> = (req: Request<ExtractParams<TPath>>, res: Response$1<TResponseBody>, ...args: [
-    ...(TBody extends RequestSchema ? [body: InferSchemaType<TBody>] : []),
-    ...(TQuery extends RequestSchema ? [query: InferSchemaType<TQuery>] : [])
-]) => void | Promise<void>;
-/**
- * Metadata for typed routes
- * Stores path and extracted parameter types
- */
-interface TypedRouteMetadata<TPath extends string = string> {
-    path: TPath;
-    params: ExtractParams<TPath>;
-}
-
-/**
- * Decorator to mark a middleware for a route or a controller class
- */
-declare const middleware: (middleware: ServerRouteMiddleware | ServerRouteMiddleware[]) => (target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => any;
-
-interface SerializeOptions {
-    /**
-     * The status code to serialize the response body against (useful only for the documentation does not affect the actual response status)
-     * @default 200
-     */
-    status?: number;
-    /**
-     * Whether to use safe serialization (returns original data if serialization fails instead of throwing)
-     * Advised to only set unsafe if development environment
-     * @default true
-     */
-    safe?: boolean;
-}
-
-declare const serialize: <T extends RequestSchema>(schema: T, options?: SerializeOptions) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
-
-declare const validate: {
-    (options: ValidationOptions & {
-        customError?: CustomValidationError;
-    }): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-    query(schema: RequestSchema, customError?: CustomValidationError): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-    body(schema: RequestSchema, customError?: CustomValidationError): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-    all(schema: RequestSchema, customError?: CustomValidationError): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-};
-
-/**
- * Base class for cron jobs with logger instance
- * @example
- * export default class MyCron extends BaseCron {
- *   @cron("* * * * *")
- *   handle() {
- *     this.logger.info("Running cron job");
- *   }
- * }
- */
-declare class BaseCron {
-    protected readonly logger: pino.Logger<string, boolean>;
-}
-
-declare class CronService {
-    static scheduledJobs: CronSchedule[];
-    /**
-     * @description Schedule a cron job.
-     * @internal
-     * @example
-     * CronService.register('test', '0 0 * * *', () => {
-     *   console.log('test');
-     * }, {
-     *   timezone: 'Europe/Istanbul',
-     * });
-     */
-    static register(name: string, ...args: CronScheduleParams): void;
-    /**
-     * @description Start the cron scheduler.
-     */
-    static run(): Promise<void>;
-    /**
-     * @description Main error handler for cron jobs. You can write your own error handler by overriding this static method for example with sentry.
-     */
-    static globalErrorHandler(context: TaskContext): void;
-    /**
-     * @description Import all cron jobs from the app/cron/schedules directory
-     */
-    static massiveImportCronJobs(cronJobPatterns: string[]): Promise<void>;
-}
-declare const setCronGlobalErrorHandler: (globalErrorHandler: (...args: Parameters<(typeof CronService)["globalErrorHandler"]>) => void) => void;
-
-/**
- * Base class for MQTT handlers with logger instance
- * @example
- * declare module "balda" {
- *   export interface BaseMqtt {
- *     logger: Logger;
- *   }
- * }
- *
- * export default class TemperatureHandler extends BaseMqtt {
- *   @mqtt("home/temperature")
- *   handle(topic: string, message: Buffer) {
- *     this.logger.info("Received temperature:", message.toString());
- *   }
- * }
- */
-declare class BaseMqtt {
-    protected readonly logger: pino.Logger<string, boolean>;
-}
-
-interface MqttTopics {
-}
-/**
- * Expands MQTT wildcard patterns to allow publishing to concrete topics
- * - "test/wildcard/+/data" allows "test/wildcard/anything/data"
- * - "test/multilevel/#" allows "test/multilevel/anything/else"
- */
-type ExpandWildcardTopic<T extends string> = T extends `${infer Before}/+/${infer After}` ? `${Before}/${string}/${ExpandWildcardTopic<After>}` : T extends `${infer Before}/+` ? `${Before}/${string}` : T extends `${infer Before}/#` ? `${Before}/${string}` : T;
-/**
- * Expands all wildcard topics in MqttTopics interface
- */
-type ExpandedMqttTopics<T extends MqttTopics> = {
-    [K in keyof T as K extends string ? ExpandWildcardTopic<K> : K]: T[K];
-};
-/**
- * Union of exact topic keys and expanded wildcard topics
- */
-type PublishTopic<T extends MqttTopics> = keyof T | keyof ExpandedMqttTopics<T>;
-type MqttHandler<T extends MqttTopics> = (topic: keyof T, message: T[keyof T]) => void | Promise<void>;
-type MqttSubscription<T extends MqttTopics> = {
-    name: string;
-    topic: keyof T;
-    handler: MqttHandler<T>;
-    options?: IClientSubscribeOptions;
-};
-type MqttSubscribeOptions = IClientSubscribeOptions;
-type MqttPublishOptions = IClientPublishOptions;
-type MqttConnectionOptions = IClientOptions;
-
-declare class MqttService {
-    static subscriptions: MqttSubscription<MqttTopics>[];
-    static client: MqttClient | null;
-    static connectionOptions: MqttConnectionOptions;
-    /**
-     * @description Register an MQTT subscription handler.
-     * @internal
-     * @example
-     * MqttService.register('test', 'home/temperature', (topic, message) => {
-     *   console.log('Received message:', message.toString());
-     * }, { qos: 1 });
-     */
-    static register<T extends MqttTopics>(name: string, topic: keyof T, handler: MqttHandler<T>, options?: IClientSubscribeOptions): void;
-    /**
-     * @description Connect to the MQTT broker and subscribe to all registered topics.
-     */
-    static connect(connectionOptions?: MqttConnectionOptions): Promise<void>;
-    /**
-     * @description Subscribe to all registered topics.
-     * @internal
-     */
-    private static subscribeToTopics;
-    /**
-     * @description Handle incoming MQTT messages.
-     * @internal
-     */
-    private static handleMessage;
-    /**
-     * @description Main error handler for MQTT operations. You can write your own error handler by overriding this static method for example with sentry.
-     */
-    static globalErrorHandler(error: Error): SyncOrAsync<void>;
-    static setOnDisconnectHandler(handler: () => void): void;
-    static setOnReconnectHandler(handler: () => void): void;
-    /**
-     * @description Import all MQTT handlers from specified patterns
-     */
-    static massiveImportMqttHandlers(mqttHandlerPatterns: string[]): Promise<void>;
-    /**
-     * Create a decorator to subscribe to an MQTT topic
-     * Messages are automatically parsed: Buffer -> JSON object (if valid) -> string
-     * Supports MQTT wildcards: + (single level) and # (multi level)
-     *
-     * Handler signature can be either:
-     * - `handler(message: T)` - just the message (topic omitted)
-     * - `handler(topic: string, message: T)` - include topic for wildcards or logging
-     *
-     * @example
-     * @mqtt.handler('home/temperature', { qos: 1 })
-     * handleTemperature(message: { value: number; unit: string }) {
-     *   console.log('Temperature:', message.value, message.unit);
-     * }
-     *
-     * @example With topic parameter (useful for wildcards)
-     * @mqtt.handler('home/+/temperature', { qos: 1 })
-     * handleRoomTemperature(topic: string, message: string) {
-     *   const room = topic.split('/')[1];
-     *   console.log(`${room} temperature:`, message);
-     * }
-     */
-    subscribe<T extends MqttTopics = MqttTopics>(topic: keyof T, options?: IClientSubscribeOptions): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-    /**
-     * @description Unsubscribe from an MQTT topic
-     * @param topic - The topic to unsubscribe from
-     * @throws BaldaError if the MQTT client is not connected
-     * @example
-     * await mqtt.unsubscribe('home/temperature');
-     */
-    unsubscribe<T extends MqttTopics>(topic: keyof T): Promise<void>;
-    /**
-     * @description Publish a message to an MQTT topic
-     * @param topic - The topic to publish to (supports wildcard expansions)
-     * @param message - The message payload (string, Buffer, or object that will be JSON stringified)
-     * @param options - Publish options (qos, retain, etc.)
-     * @throws BaldaError if the MQTT client is not connected or is not installed as a dependency
-     */
-    publish<T extends MqttTopics>(topic: PublishTopic<T>, message: T[keyof T], options?: MqttPublishOptions): Promise<void>;
-    /**
-     * @description Disconnect the MQTT client gracefully
-     */
-    static disconnect(): Promise<void>;
-}
-declare const setMqttGlobalErrorHandler: (globalErrorHandler: (...args: Parameters<(typeof MqttService)["globalErrorHandler"]>) => void) => void;
-/**
- * Singleton instance for publishing MQTT messages
- * @example
- * import { mqtt } from 'balda';
- *
- * await mqtt.publish('home/temperature', { value: 23.5, unit: 'C' }, { qos: 1 });
- */
-declare const mqtt: MqttService;
-
-/**
- * Base class for queue handlers with logger instance
- * @example
- * const myQueue = bullmqQueue<MyPayload>("my-topic");
- *
- * export default class MyQueue extends BaseQueue {
- *   @myQueue.subscribe()
- *   async handle(payload: MyPayload) {
- *     this.logger.info({ payload }, "Processing queue message");
- *   }
- * }
- */
-declare class BaseQueue {
-    protected readonly logger: pino.Logger<string, boolean>;
-}
-
-declare class BullMQPubSub implements GenericPubSub {
-    private queues;
-    private workers;
-    private bullmqClient;
-    publish<TPayload>(topic: string, payload: TPayload, options?: PublishOptions<"bullmq">): Promise<{
-        id: string;
-    }>;
-    subscribe<TPayload>(topic: string, handler: (payload: TPayload) => Promise<void>): Promise<void>;
-    unsubscribe(topic: string): Promise<void>;
-    private getQueue;
-    private getBullMQClient;
-    publishWithConfig<TPayload>(topic: string, payload: TPayload, options?: PublishOptions<"bullmq">, queueConfig?: BullMQQueueOptions): Promise<{
-        id: string;
-    }>;
-    subscribeWithConfig<TPayload>(topic: string, handler: (payload: TPayload) => Promise<void>, queueConfig?: BullMQQueueOptions): Promise<void>;
-    private getQueueWithConfig;
-    private getQueueKey;
-    private getWorkerKey;
-}
-
-declare class MemoryPubSub implements GenericPubSub {
-    private subscribers;
-    private messageQueue;
-    private readonly maxQueueSize;
-    private processingPromise;
-    constructor(maxQueueSize?: number);
-    /**
-     * Clear all subscribers and pending messages
-     * @internal Used for test cleanup
-     */
-    clear(): void;
-    publish<TPayload>(topic: string, payload: TPayload, _options?: Record<string, unknown>): Promise<{
-        id: string;
-    }>;
-    subscribe<TPayload>(topic: string, handler: (payload: TPayload) => Promise<void>): Promise<void>;
-    unsubscribe(topic: string): Promise<void>;
-    private processQueue;
-}
-
-declare class PGBossPubSub implements GenericPubSub {
-    private boss;
-    private createdQueues;
-    private workers;
-    publish<TPayload>(topic: string, payload: TPayload, options?: PublishOptions<"pgboss">): Promise<{
-        id: string;
-    }>;
-    subscribe<TPayload>(topic: string, handler: (payload: TPayload) => Promise<void>): Promise<void>;
-    unsubscribe(topic: string): Promise<void>;
-    private getBoss;
-    private ensureQueue;
-    publishWithConfig<TPayload>(topic: string, payload: TPayload, options?: PublishOptions<"pgboss">, queueConfig?: PGBossQueueOptions): Promise<{
-        id: string;
-    }>;
-    subscribeWithConfig<TPayload>(topic: string, handler: (payload: TPayload) => Promise<void>, queueConfig?: PGBossQueueOptions): Promise<void>;
-    private bossInstances;
-    private getBossWithConfig;
-    private ensureQueueWithBoss;
-}
-
-declare class SQSPubSub implements GenericPubSub {
-    private consumers;
-    private client?;
-    private sqsLib;
-    private sqsConsumerLib;
-    publish<TPayload>(topic: string, payload: TPayload, options?: PublishOptions<"sqs">): Promise<{
-        id: string;
-    }>;
-    subscribe<TPayload>(topic: string, handler: (payload: TPayload) => Promise<void>): Promise<void>;
-    unsubscribe(topic: string): Promise<void>;
-    private getClient;
-    private getSqsLib;
-    private getSqsConsumerLib;
-    private resolveQueueUrl;
-    publishWithConfig<TPayload>(topic: string, payload: TPayload, options?: PublishOptions<"sqs">, queueConfig?: SQSQueueOptions): Promise<{
-        id: string;
-    }>;
-    subscribeWithConfig<TPayload>(topic: string, handler: (payload: TPayload) => Promise<void>, queueConfig?: SQSQueueOptions): Promise<void>;
-    private getClientWithConfig;
-}
-
-type BullMQAddTaskOptions = JobsOptions;
-type PGBossSendOptions = SendOptions;
-type SQSPublishOptions = Omit<SendMessageCommandInput, "MessageBody">;
-/**
- * Built-in provider keys
- */
-type BuiltInProviderKey = "bullmq" | "sqs" | "pgboss" | "memory";
-type PublishOptions<T extends BuiltInProviderKey> = T extends "bullmq" ? BullMQAddTaskOptions : T extends "sqs" ? SQSPublishOptions : T extends "pgboss" ? PGBossSendOptions : T extends "memory" ? Record<string, unknown> : never;
-type SQSQueueOptions = {
-    queueUrl: string;
-    client?: SQSClientConfig;
-};
-type BullMQQueueOptions = ConstructorParameters<typeof Queue>[1];
-type PGBossQueueOptions = {
-    connectionString?: string;
-};
-/**
- * Generic PubSub interface for typed queues
- * @template TPayload - The type of the payload
- * @returns A Promise that resolves to an object with an id property
- * @example
- * ```typescript
- * const pubsub: GenericPubSub<{ name: string }> = {
- *   async publish(topic, payload, options) {
- *     return { id: '123' };
- *   },
- *   async subscribe(topic, handler) {
- *     console.log('subscribed');
- *   },
- *   async unsubscribe(topic) {
- *     console.log('unsubscribed');
- *   },
- * };
- * ```
- */
-interface GenericPubSub<TPayload = unknown> {
-    publish(topic: string, payload: TPayload, options?: Record<string, unknown>): Promise<{
-        id: string;
-    }>;
-    subscribe(topic: string, handler: (payload: TPayload) => Promise<void>): Promise<void>;
-    unsubscribe(topic: string): Promise<void>;
-}
-interface QueueProvider {
-    bullmq: BullMQPubSub;
-    sqs: SQSPubSub;
-    pgboss: PGBossPubSub;
-    memory: MemoryPubSub;
-}
-type QueueProviderKey = keyof QueueProvider;
-
-type QueueOptionsForProvider<P extends BuiltInProviderKey> = P extends "sqs" ? SQSQueueOptions : P extends "bullmq" ? BullMQQueueOptions : P extends "pgboss" ? PGBossQueueOptions : P extends "memory" ? Record<string, unknown> : never;
-/**
- * TypedQueue for built-in providers (sqs, bullmq, pgboss)
- */
-declare class TypedQueue<TPayload, TProvider extends BuiltInProviderKey = BuiltInProviderKey> {
-    readonly topic: string;
-    readonly provider: TProvider;
-    private readonly queueOptions?;
-    constructor(topic: string, provider: TProvider, queueOptions?: QueueOptionsForProvider<TProvider> | undefined);
-    publish(payload: TPayload, options?: PublishOptions<TProvider>): Promise<{
-        id: string;
-    }>;
-    /**
-     * Subscribe to the queue, to be used as a decorator on a class method
-     * @example
-     * ```ts
-     * @queue.subscribe()
-     * async handle(payload: TPayload) {
-     *   console.log(payload);
-     * }
-     * ```
-     */
-    subscribe(): MethodDecorator;
-    /**
-     * Subscribe to the queue with the given handler
-     * @param handler - The handler function to subscribe to the queue
-     * @returns A promise that resolves when subscription is complete
-     * @example
-     * ```ts
-     * await queue.subscribe(async (payload: TPayload) => {
-     *   console.log(payload);
-     * });
-     * // Later: await queue.unsubscribe()
-     * ```
-     */
-    subscribe(handler: (payload: TPayload) => Promise<void>): Promise<void>;
-    /**
-     * Unsubscribe from the queue
-     * @returns A promise that resolves when unsubscription is complete
-     * @example
-     * ```ts
-     * await queue.unsubscribe();
-     * ```
-     */
-    unsubscribe(): Promise<void>;
-    private createSubscribeDecorator;
-    private subscribeWithCallback;
-}
-/**
- * CustomTypedQueue for user-defined custom providers
- */
-declare class CustomTypedQueue<TPayload, TOptions = Record<string, unknown>> {
-    readonly topic: string;
-    private readonly pubsub;
-    constructor(topic: string, pubsub: GenericPubSub<TPayload>);
-    publish(payload: TPayload, options?: TOptions): Promise<{
-        id: string;
-    }>;
-    subscribe(): MethodDecorator;
-    subscribe(handler: (payload: TPayload) => Promise<void>): Promise<void>;
-    /**
-     * Unsubscribe from the queue
-     * @returns A promise that resolves when unsubscription is complete
-     * @example
-     * ```ts
-     * await queue.unsubscribe();
-     * ```
-     */
-    unsubscribe(): Promise<void>;
-    private createSubscribeDecorator;
-}
-
-/**
- * Create a typed SQS queue
- * @param topic - The queue topic name
- * @param options - SQS-specific options including queueUrl
- * @returns A TypedQueue instance for SQS
- *
- * @example
- * ```typescript
- * const userQueue = sqsQueue<{ userId: string }>('user-events', {
- *   queueUrl: 'https://sqs.us-east-1.amazonaws.com/123456789/my-queue'
- * });
- *
- * // Publishing
- * await userQueue.publish({ userId: '123' });
- *
- * // Subscribing with decorator
- * class UserHandler {
- *   @userQueue.subscribe()
- *   async handle(payload: { userId: string }) {}
- * }
- *
- * // Subscribing with callback
- * await userQueue.subscribe(async (payload) => {
- *   console.log(payload.userId);
- * });
- * ```
- */
-declare function sqsQueue<TPayload>(topic: string, options?: SQSQueueOptions): TypedQueue<TPayload, "sqs">;
-/**
- * Create a typed BullMQ queue
- * @param topic - The queue topic name
- * @param options - BullMQ-specific options (connection, job options, etc.)
- * @returns A TypedQueue instance for BullMQ
- *
- * @example
- * ```typescript
- * const orderQueue = bullmqQueue<{ orderId: number }>('orders', {
- *   connection: { host: 'localhost', port: 6379 }
- * });
- *
- * // Publishing
- * await orderQueue.publish({ orderId: 123 });
- *
- * // Subscribing with decorator
- * class OrderHandler {
- *   @orderQueue.subscribe()
- *   async handle(payload: { orderId: number }) {}
- * }
- * ```
- */
-declare function bullmqQueue<TPayload>(topic: string, options?: BullMQQueueOptions): TypedQueue<TPayload, "bullmq">;
-/**
- * Create a typed PGBoss queue
- * @param topic - The queue topic name
- * @param options - PGBoss-specific options
- * @returns A TypedQueue instance for PGBoss
- *
- * @example
- * ```typescript
- * const notificationQueue = pgbossQueue<{ message: string }>('notifications');
- *
- * // Publishing
- * await notificationQueue.publish({ message: 'Hello!' });
- *
- * // Subscribing with decorator
- * class NotificationHandler {
- *   @notificationQueue.subscribe()
- *   async handle(payload: { message: string }) {}
- * }
- * ```
- */
-declare function pgbossQueue<TPayload>(topic: string, options?: PGBossQueueOptions): TypedQueue<TPayload, "pgboss">;
-/**
- * Create a typed in-memory queue
- * @param topic - The queue topic name
- * @returns A TypedQueue instance for in-memory processing
- *
- * @example
- * ```typescript
- * const emailQueue = memoryQueue<{ to: string; subject: string }>('emails');
- *
- * // Publishing
- * await emailQueue.publish({ to: 'user@example.com', subject: 'Hello' });
- *
- * // Subscribing with decorator
- * class EmailHandler {
- *   @emailQueue.subscribe()
- *   async handle(payload: { to: string; subject: string }) {}
- * }
- * ```
- */
-declare function memoryQueue<TPayload>(topic: string): TypedQueue<TPayload, "memory">;
-/**
- * Create a typed queue with a custom PubSub provider
- * @param topic - The queue topic name
- * @param pubsub - A custom PubSub implementation
- * @returns A CustomTypedQueue instance for the custom provider
- *
- * @example
- * ```typescript
- * const customProvider: GenericPubSub<MyPayload> = {
- *   async publish(topic, payload, options) {
- *     // Custom publish logic
- *     return { id: 'custom-id' };
- *   },
- *   async subscribe(topic, handler) {
- *     // Custom subscribe logic
- *   }
- * };
- *
- * const customQueue = createQueue<{ data: string }>('custom-topic', customProvider);
- *
- * await customQueue.publish({ data: 'test' });
- * ```
- */
-declare function createQueue<TPayload, TOptions = Record<string, unknown>>(topic: string, pubsub: GenericPubSub<TPayload>): CustomTypedQueue<TPayload, TOptions>;
-
-/**
- * Options for BullMQ configuration
- * @param options - The options for BullMQ
- * @param errorHandler - Custom error handler that will be triggered when a job fails, for logging or debug purposes
- */
-type BullMQConfigurationOptions = ConstructorParameters<typeof Queue>[1] & {
-    errorHandler?: (job: Job, error: Error) => SyncOrAsync;
-};
-declare class BullMQConfiguration {
-    static options: BullMQConfigurationOptions;
-}
-/**
- * Define globally custom BullMQ configuration
- * @param options - The BullMQ configuration options
- */
-declare const defineBullMQConfiguration: (options: BullMQConfigurationOptions) => void;
-
-type CustomQueueConfiguration = GenericPubSub;
-
-type PGBossConfigurationOptions = {
-    connectionString?: string;
-    boss?: unknown;
-    errorHandler?: (error: Error) => SyncOrAsync;
-};
-declare class PGBossConfiguration {
-    static options: PGBossConfigurationOptions;
-}
-declare const definePGBossConfiguration: (options: PGBossConfigurationOptions) => void;
-
-type SQSConfigurationOptions = {
-    client?: SQSClientConfig;
-    consumer?: {
-        batchSize?: number;
-        visibilityTimeout?: number;
-        waitTimeSeconds?: number;
-        queueUrlMap: Record<string, string>;
-    };
-    errorHandler?: (error: Error) => SyncOrAsync;
-};
-declare class SQSConfiguration {
-    static options: SQSConfigurationOptions;
-}
-declare const defineSQSConfiguration: (options: SQSConfigurationOptions) => void;
-
-declare class QueueManager {
-    static map: Map<QueueProviderKey, GenericPubSub>;
-    static getProvider<P extends QueueProviderKey>(provider: P): GenericPubSub<P>;
-    static setProvider(provider: QueueProviderKey, pubsub: GenericPubSub<QueueProviderKey>): void;
-    /**
-     * Clear the memory provider state
-     * @internal Used for test cleanup
-     */
-    static clearMemoryProvider(): void;
-}
-
-/**
- * Main entry point to define the queue configuration, meant to be called only once in the application bootstrap
- * @bullmq - The BullMQ configuration options
- * @pgboss - The PGBoss configuration options
- * @sqs - The SQS configuration options
- * @string - The custom queue provider name with it's PubSub implementation
- * @example
- * defineQueueConfiguration({
- *   bullmq: {
- *     connection: {
- *       host: "127.0.0.1",
- *       password: "root",
- *       username: "default",
- *       db: 0,
- *     },
- *   },
- *   pgboss: {
- *     connectionString: "postgres://root:root@localhost:5432/database",
- *   },
- *   sqs: {
- *     client: { region: "us-east-1" },
- *   },
- *   custom: new CustomPubSub(),
- * });
- * @example
- * defineQueueConfiguration({
- *   custom: new CustomPubSub(),
- * });
- */
-declare const defineQueueConfiguration: (options: {
-    bullmq?: Parameters<typeof defineBullMQConfiguration>[0];
-    pgboss?: Parameters<typeof definePGBossConfiguration>[0];
-    sqs?: Parameters<typeof defineSQSConfiguration>[0];
-} & { [key in Exclude<QueueProviderKey, "bullmq" | "pgboss" | "sqs">]?: CustomQueueConfiguration; }) => void;
-
-type QueueHandler = (payload: unknown) => Promise<void>;
-type TypedQueueRegistration = {
-    name: string;
-    topic: string;
-    handler: QueueHandler;
-    provider: BuiltInProviderKey;
-    queueOptions?: unknown;
-};
-type CustomQueueRegistration = {
-    name: string;
-    topic: string;
-    handler: QueueHandler;
-    pubsub: GenericPubSub;
-};
-declare class QueueService {
-    static typedQueueSubscribers: Map<string, TypedQueueRegistration>;
-    static customQueueSubscribers: Map<string, CustomQueueRegistration>;
-    /**
-     * Factory function for creating handler instances.
-     * Can be overridden to provide custom dependency injection.
-     * @default Creates new instance using constructor
-     */
-    static instanceFactory: (ctor: Function) => object;
-    static registerTypedQueue(name: string, topic: string, handler: QueueHandler, provider: BuiltInProviderKey, queueOptions?: unknown): void;
-    static registerCustomQueue(name: string, topic: string, handler: QueueHandler, pubsub: GenericPubSub): void;
-    static run(): Promise<void>;
-    static massiveImportQueues(queueHandlerPatterns: string[], options?: {
-        throwOnError?: boolean;
-    }): Promise<void>;
-}
-
-/**
- * The logger instance, can be overridden by the `defineLoggerConfig` function
- */
-declare let logger: pino__default.Logger<string, boolean>;
-/**
- * Define the logger config, this will override the logger instance with the given options
- * @param options - The logger options
- */
-declare const defineLoggerConfig: (options?: LoggerOptions) => void;
-
-type Argument = string;
-type FlagSchema = Record<string, string | number | boolean | Array<string | number | boolean>>;
-
-type CommandOptions = {
-    /**
-     * If true, the command won't be killed after it's finished. Defaults to false.
-     */
-    keepAlive?: boolean;
-    /**
-     * Category for grouping commands in help output
-     * @example 'generator', 'development', 'production', 'database'
-     */
-    category?: string;
-    /**
-     * Mark command as deprecated with optional replacement
-     * @example { message: 'Use generate-controller instead', replacement: 'generate-controller' }
-     */
-    deprecated?: {
-        message?: string;
-        replacement?: string;
-    };
-    /**
-     * Custom validation function that runs before handle()
-     */
-    validate?: (command: typeof Command) => boolean | Promise<boolean>;
-};
-
-/**
- * Base class for all cli commands.
- * @abstract
- */
-declare abstract class Command {
-    /**
-     * The name of the command.
-     */
-    static commandName: string;
-    /**
-     * package manager that called the command (e.g. npx, yarn, bun etc.)
-     */
-    static calledBy: string;
-    /**
-     * The description of the command.
-     */
-    static description: string;
-    /**
-     * The help text of the command.
-     */
-    static help: string[] | string;
-    /**
-     * The options of the command.
-     */
-    static options: CommandOptions;
-    /**
-     * Static arguments in order to be validated by decorators. Will be fetched in the command instance.
-     */
-    static args: Argument[];
-    /**
-     * Static flags in order to be validated by decorators. Will be fetched in the command instance.
-     */
-    static flags: FlagSchema;
-    static readonly logger: pino.Logger<string, boolean>;
-    /**
-     * Main entry point for the command.
-     */
-    static handle(): Promise<void>;
-    /**
-     * Enhanced help flag handler with rich formatting and command information
-     */
-    static handleHelpFlag(flags: FlagSchema): void;
-    private static readonly generateHelpOutput;
-    static readonly validateContext: (target: any) => void;
-}
-
-declare class BuildCommand extends Command {
-    static commandName: string;
-    static description: string;
-    static help: string[];
-    static clearDist: boolean;
-    static entry: string;
-    static output: string;
-    static tsconfig: string;
-    static assets: string;
-    static format: "esm" | "cjs";
-    static packages: "external" | "bundle";
-    static sourcemap: boolean;
-    static handle(): Promise<void>;
-}
-
-declare class CronStartCommand extends Command {
-    static commandName: string;
-    static description: string;
-    static help: string[];
-    static options: CommandOptions;
-    static pattern: string;
-    static additionalPatterns?: string[];
-    static handle(): Promise<void>;
-}
-
-declare class GenerateCommand extends Command {
-    static commandName: string;
-    static description: string;
-    static help: string[];
-    /**
-     * The path where the command will be generated
-     */
-    static path: string;
-    static name: string;
-    static handle(): Promise<void>;
-    static getCommandTemplate(): string;
-}
-
-declare class GenerateControllerCommand extends Command {
-    static commandName: string;
-    static description: string;
-    static help: string[];
-    static controllerName: string;
-    static path: string;
-    static handle(): Promise<void>;
-    static getControllerTemplate(): string;
-}
-
-declare class GenerateCron extends Command {
-    static commandName: string;
-    static description: string;
-    static help: string[];
-    static fileName: string;
-    static path: string;
-    static handle(): Promise<void>;
-    static getCronTemplate(): string;
-}
-
-declare class GenerateMiddlewareCommand extends Command {
-    static commandName: string;
-    static description: string;
-    static help: string[];
-    static middlewareName: string;
-    static path: string;
-    static handle(): Promise<void>;
-    static getMiddlewareTemplate(): string;
-}
-
-declare class GenerateMqttCommand extends Command {
-    static commandName: string;
-    static description: string;
-    static help: string[];
-    static path: string;
-    static topic: string;
-    static handle(): Promise<void>;
-    static getMqttTemplate(isValidLiteral: boolean): string;
-}
-
-declare class GeneratePluginCommand extends Command {
-    static commandName: string;
-    static description: string;
-    static help: string[];
-    static pluginName: string;
-    static pluginPath: string;
-    static handle(): Promise<void>;
-    static getPluginTemplate(): string;
-}
-
-declare class GenerateQueueCommand extends Command {
-    static commandName: string;
-    static description: string;
-    static help: string[];
-    static queueName: string;
-    static path: string;
-    static provider: string;
-    static handle(): Promise<void>;
-    static getQueueTemplate(isValidLiteral: boolean): string;
-}
-
-declare class GenerateSdkCommand extends Command {
-    static commandName: string;
-    static description: string;
-    static help: string[];
-    static serverPath: string;
-    static outputPath: string;
-    static swaggerPath?: string;
-    static httpClient: string;
-    static unwrapResponseData: boolean;
-    static singleHttpClient: boolean;
-    static typePrefix?: string;
-    static typeSuffix?: string;
-    static enumNamesAsValues: boolean;
-    static sortTypes: boolean;
-    static handle(): Promise<void>;
-}
-
-declare class InitCommand extends Command {
-    static commandName: string;
-    static description: string;
-    static help: string[];
-    static srcPath: string;
-    static typescript: boolean;
-    static mqtt: boolean;
-    static cron: boolean;
-    static graphql: boolean;
-    static devDependencies: string[];
-    static handle(): Promise<void>;
-    static getServerTemplate(): string;
-    static getIndexTemplate(): string;
-    static getMqttConfigTemplate(): string;
-    static getCronConfigTemplate(): string;
-    static getGraphqlConfigTemplate(): string;
-}
-
-declare class InitMailerCommand extends Command {
-    static commandName: string;
-    static description: string;
-    static help: string[];
-    static templateEngine: "handlebars" | "ejs" | "edge" | "mustache" | "custom" | "none";
-    static outputPath: string;
-    static mailerDependencies: Record<string, string[]>;
-    static handle(): Promise<void>;
-    static getConfigTemplate(): string;
-    static getAdapterImport(): string;
-    static getTemplateAdapterSetup(): string;
-    static getTemplateExample(): string;
-}
-
-declare class InitQueueCommand extends Command {
-    static commandName: string;
-    static description: string;
-    static help: string[];
-    static queueType: "bullmq" | "sqs" | "pgboss";
-    static outputPath: string;
-    static queueDependencies: Record<string, string[]>;
-    static handle(): Promise<void>;
-    static getConfigTemplate(): string;
-    static getBullMQTemplate(): string;
-    static getSQSTemplate(): string;
-    static getPGBossTemplate(): string;
-}
-
-declare class KeyGenerateCommand extends Command {
-    static commandName: string;
-    static description: string;
-    static help: string[];
-    static type?: string;
-    static handle(): Promise<void>;
-    private static saveKeyToEnvFile;
-}
-
-declare class ListCommand extends Command {
-    static commandName: string;
-    static description: string;
-    static help: string[];
-    static handle(): Promise<void>;
-    private static groupByCategory;
-    private static displayCategorizedCommands;
-}
-
-declare class ServeCommand extends Command {
-    static commandName: string;
-    static description: string;
-    static help: string[];
-    static runtime: RunTimeType;
-    static options: CommandOptions;
-    static entry: string;
-    static denoImportMap?: string;
-    static handle(): Promise<void>;
-    private static handleNodeHotReload;
-}
-
-declare class SetupStorageCommand extends Command {
-    static commandName: string;
-    static description: string;
-    static help: string[];
-    static storageType: string;
-    static outputPath: string;
-    static handle(): Promise<void>;
-    private static getDependencies;
-    private static checkMissingDependencies;
-    private static createStorageSetup;
-    private static getConfigTemplate;
-}
-
-declare const baseCommands: (typeof BuildCommand | typeof CronStartCommand | typeof GenerateCommand | typeof GenerateControllerCommand | typeof GenerateCron | typeof GenerateMiddlewareCommand | typeof GenerateMqttCommand | typeof GeneratePluginCommand | typeof GenerateQueueCommand | typeof GenerateSdkCommand | typeof InitCommand | typeof InitMailerCommand | typeof InitQueueCommand | typeof KeyGenerateCommand | typeof ListCommand | typeof ServeCommand | typeof SetupStorageCommand)[];
-/**
- * Singleton that registers all commands and provides a way to execute them.
- * Commands are loaded from the commands directory, and are expected to have a default export with the command class that extends the base command class.
- * Commands can be run both as `.js` or `.ts` files. If the file is a ts file `typescript` npm package must be installed.
- * You can use the `CommandRegistry.setCommandsPattern` method to change the pattern of the commands to load.
- * @example
- * // commands/test.ts
- * export default class TestCommand extends Command {
- *   static name = "test";
- *   async handle() {
- *     console.log("Test command");
- *   }
- * }
- */
-declare class CommandRegistry {
-    private commands;
-    private builtInCommands;
-    static commandsPattern: string;
-    static logger: pino.Logger<string, boolean>;
-    /**
-     * Private constructor to prevent direct instantiation
-     * @internal Not meant to be used outside by the user
-     */
-    private constructor();
-    static getInstance(): CommandRegistry;
-    static setCommandsPattern(pattern: string): void;
-    getCommand(name: string): typeof Command | null;
-    getCommands(): (typeof Command)[];
-    getBuiltInCommands(): (typeof Command)[];
-    getUserDefinedCommands(): (typeof Command)[];
-    isBuiltInCommand(commandName: string): boolean;
-    loadCommands(commandsPattern: string): Promise<void>;
-}
-declare const commandRegistry: CommandRegistry;
-
-declare class NativeHash {
-    private ITERATIONS;
-    private SALT_LENGTH;
-    private KEY_LENGTH;
-    configure(options: {
-        iterations?: number;
-        saltLength?: number;
-        keyLength?: number;
-    }): void;
-    hash(data: string): Promise<string>;
-    compare(hash: string, data: string): Promise<boolean>;
-    private encodeBase64;
-    private decodeBase64;
-}
-declare const hash: NativeHash;
-
-declare const asyncStorage: AsyncLocalStorage<Record<string, any>>;
-/**
- * Async local storage plugin middleware, used to store data in the request context
- */
-declare const asyncLocalStorage: (ctxSetters: AsyncLocalStorageContextSetters) => ServerRouteMiddleware;
-
-type LocalStorageProviderOptions = {
-    /**
-     * The directory to store the files
-     */
-    directory: string;
-};
-/**
- * Local storage provider, stores files in the local filesystem
- * Note: This provider does not support signed URLs (getDownloadUrl/getUploadUrl)
- */
-declare class LocalStorageProvider implements StorageInterface {
-    private readonly options;
-    private wasDirectoryEnsured;
-    constructor(options: LocalStorageProviderOptions);
-    getDownloadUrl(_key: string, _expiresInSeconds?: number): Promise<string>;
-    getUploadUrl(_key: string, _expiresInSeconds?: number): Promise<string>;
-    getPublicUrl(_key: string): Promise<string>;
-    listObjects(prefix?: string): Promise<string[]>;
-    getObject<R extends ReturnType$1 = "raw">(key: string, returnType?: R): Promise<ReturnTypeMap<R>>;
-    putObject<T = Uint8Array>(key: string, value: T, _contentType?: string): Promise<void>;
-    deleteObject(key: string): Promise<void>;
-    private listFilesRecursively;
-    private readDirectory;
-    private ensureDirectoryExists;
-}
-
-type S3ClientConfig = ConstructorParameters<typeof S3Client>[0];
-type S3StorageProviderOptions = {
-    s3ClientConfig: S3ClientConfig & {
-        bucketName: string;
-    };
-    /**
-     * The cloudfront options (optional), allows to get the cloudfront signed url for an object, enables the `getDownloadUrl` method that throws an error if not configured
-     */
-    cloudfrontOptions?: {
-        /**
-         * The CloudFront distribution domain name (e.g., 'd1234567890.cloudfront.net')
-         */
-        domainName: string;
-        /**
-         * The CloudFront key pair ID
-         */
-        keyPairId: string;
-        /**
-         * The private key in PEM format for signing URLs
-         */
-        privateKey: string;
-    };
-};
-declare class S3StorageProvider implements StorageInterface {
-    private s3Lib;
-    private s3PresignerLib;
-    private cloudfrontSignerLib;
-    private s3Client;
-    readonly options: S3StorageProviderOptions;
-    constructor(options: S3StorageProviderOptions);
-    getDownloadUrl(key: string, expiresInSeconds?: number): Promise<string>;
-    getUploadUrl(key: string, expiresInSeconds?: number): Promise<string>;
-    getPublicUrl(key: string): Promise<string>;
-    listObjects(prefix?: string): Promise<string[]>;
-    getObject<R extends ReturnType$1 = "raw">(key: string, returnType?: R): Promise<ReturnTypeMap<R>>;
-    putObject<T = Uint8Array>(key: string, value: T, contentType?: string): Promise<void>;
-    deleteObject(key: string): Promise<void>;
-    private ensureClient;
-}
-
-type ReturnType$1 = "raw" | "text" | "stream";
-type ReturnTypeMap<T extends ReturnType$1> = T extends "raw" ? Uint8Array : T extends "text" ? string : T extends "stream" ? ReadableStream : never;
-/**
- * High level storage interface, provides a unified way to interact with different storage providers
- */
-interface StorageInterface {
-    /**
-     * Get the download signed url of the object
-     * @param key - The key of the object
-     * @returns The download signed url of the object
-     * @warning not available in local storage provider
-     * @throws if using local storage provider
-     */
-    getDownloadUrl: (key: string, expiresInSeconds?: number) => Promise<string>;
-    /**
-     * Get the upload signed url of the object
-     * @param key - The key of the object
-     * @returns The upload signed url of the object
-     * @warning not available in local storage provider
-     * @throws if using local storage provider
-     */
-    getUploadUrl: (key: string, expiresInSeconds?: number) => Promise<string>;
-    /**
-     * Get the public url of the object
-     * @param key - The key of the object
-     * @returns The public url of the object
-     * @warning not available in local storage provider
-     * @throws if using local storage provider
-     */
-    getPublicUrl: (key: string) => Promise<string>;
-    /**
-     * List the objects from the storage
-     * @param prefix - The prefix of the objects
-     * @returns The objects from the storage
-     */
-    listObjects: (prefix?: string) => Promise<string[]>;
-    /**
-     * Get the object from the storage
-     * @param key - The key of the object
-     * @throws If no file is found for the given key
-     * @returns The object from the storage
-     */
-    getObject: <R extends ReturnType$1 = "raw">(key: string, returnType: R) => Promise<ReturnTypeMap<R>>;
-    /**
-     * Put the object into the storage
-     * @param key - The key of the object
-     * @param value - The value of the object
-     * @param contentType - The content type of the object
-     * @returns The object from the storage
-     */
-    putObject: <T = Uint8Array>(key: string, value: T, contentType?: string) => Promise<void>;
-    /**
-     * Delete the object from the storage
-     * @param key - The key of the object
-     * @returns The object from the storage
-     */
-    deleteObject: (key: string) => Promise<void>;
-}
-type StorageOptions<T extends BaseStorageProviderOptions> = {
-    /**
-     * The default provider to use
-     */
-    defaultProvider: keyof T;
-};
-/**
- * Mapping of the storage provider options
- */
-interface BaseStorageProviderOptions {
-    local?: LocalStorageProvider;
-    s3?: S3StorageProvider;
-    azureBlobStorage?: AzureBlobStorageProvider;
-}
-/**
- * Custom storage providers
- */
-interface CustomStorageProviderOptions {
-    [key: string]: StorageInterface;
-}
-type StorageProviderOptions = CustomStorageProviderOptions & BaseStorageProviderOptions;
-
-type BlobStorageProviderOptions = {
-    /**
-     * The container name
-     */
-    containerName: string;
-    /**
-     * The connection string to the storage account
-     */
-    connectionString: string;
-    /**
-     * The storage account name
-     */
-    storageAccountName: string;
-    /**
-     * The storage account key
-     */
-    storageAccountKey: string;
-};
-declare class AzureBlobStorageProvider implements StorageInterface {
-    private readonly options;
-    private azureBlobLib;
-    private blobServiceClient;
-    private containerClient;
-    private sharedKeyCredential;
-    constructor(options: BlobStorageProviderOptions);
-    getDownloadUrl(key: string, expiresInSeconds?: number): Promise<string>;
-    getUploadUrl(key: string, expiresInSeconds?: number): Promise<string>;
-    getPublicUrl(key: string): Promise<string>;
-    listObjects(prefix?: string): Promise<string[]>;
-    getObject<R extends ReturnType$1 = "raw">(key: string, returnType?: R): Promise<ReturnTypeMap<R>>;
-    putObject<T = Uint8Array>(key: string, value: T, contentType?: string): Promise<void>;
-    deleteObject(key: string): Promise<void>;
-    private ensureClient;
-}
-
-declare class Storage<T extends StorageProviderOptions> implements StorageInterface {
-    private readonly providerOptions;
-    private readonly defaultProvider;
-    private readonly providerMap;
-    constructor(providerOptions: T, storageOptions: StorageOptions<T>);
-    /**
-     * Use a specific provider
-     * @param provider - The provider to use
-     * @returns The storage instance
-     */
-    use(provider: keyof T): StorageInterface;
-    getDownloadUrl(key: string, expiresInSeconds?: number): Promise<string>;
-    getUploadUrl(key: string, expiresInSeconds?: number): Promise<string>;
-    getPublicUrl(key: string): Promise<string>;
-    listObjects(prefix?: string): Promise<string[]>;
-    getObject<R extends ReturnType$1 = "raw">(key: string, returnType?: R): Promise<ReturnTypeMap<R>>;
-    putObject<T = Buffer<ArrayBufferLike>>(key: string, value: T, contentType?: string): Promise<void>;
-    deleteObject(key: string): Promise<void>;
-}
-
-/**
- * Email address type that enforces the basic email format
- */
-type Email = `${string}@${string}`;
-/**
- * Builder for constructing email options
- */
-declare class MailOptionsBuilder {
-    private options;
-    private templateOptions?;
-    /**
-     * Set the sender email address
-     * @param email - The sender email address
-     */
-    from(email: Email): this;
-    /**
-     * Set recipient email address(es)
-     * @param email - Single email address or array of email addresses
-     */
-    to(email: Email | Email[]): this;
-    /**
-     * Set carbon copy recipient email address(es)
-     * @param email - Single email address or array of email addresses
-     */
-    cc(email: Email | Email[]): this;
-    /**
-     * Set blind carbon copy recipient email address(es)
-     * @param email - Single email address or array of email addresses
-     */
-    bcc(email: Email | Email[]): this;
-    /**
-     * Set email subject
-     * @param text - The email subject line
-     */
-    subject(text: string): this;
-    /**
-     * Set plain text email body
-     * @param content - The plain text content of the email
-     */
-    text(content: string): this;
-    /**
-     * Set HTML email body
-     * @param content - The HTML content of the email
-     */
-    html(content: string): this;
-    /**
-     * Set template string and data for rendering
-     * @param template - The template string to render
-     * @param data - The data to pass to the template for rendering
-     */
-    template(template: string, data: Record<string, unknown>): this;
-    /**
-     * Set template file path and data for rendering
-     * @param templatePath - The path to the template file
-     * @param data - The data to pass to the template for rendering
-     */
-    templateFile(templatePath: string, data: Record<string, unknown>): this;
-    /**
-     * Add an attachment
-     * @param attachment - The attachment to add to the email
-     */
-    attachment(attachment: Attachment): this;
-    /**
-     * Add multiple attachments
-     * @param attachments - Array of attachments to add to the email
-     */
-    attachments(attachments: Attachment[]): this;
-    /**
-     * Check if this builder has template options
-     */
-    hasTemplate(): boolean;
-    /**
-     * Check if the template is a file path
-     */
-    isTemplateFile(): boolean;
-    /**
-     * Build the final MailOptions or TemplateMailOptions object
-     */
-    build(): MailOptions | TemplateMailOptions;
-}
-/**
- * Helper function to create a new MailOptionsBuilder
- */
-declare const mailOptions: () => MailOptionsBuilder;
-
-/**
- * Options for sending an email
- */
-type MailOptions = {
-    /**
-     * The sender email address (optional if set in provider config)
-     */
-    from?: Email;
-    /**
-     * Recipient email address(es)
-     */
-    to: Email | Email[];
-    /**
-     * Carbon copy recipient email address(es)
-     */
-    cc?: Email | Email[];
-    /**
-     * Blind carbon copy recipient email address(es)
-     */
-    bcc?: Email | Email[];
-    /**
-     * Email subject line
-     */
-    subject: string;
-    /**
-     * Plain text version of the email body
-     */
-    text?: string;
-    /**
-     * HTML version of the email body
-     */
-    html?: string;
-    /**
-     * Email attachments
-     */
-    attachments?: Attachment[];
-};
-/**
- * Email attachment configuration
- */
-type Attachment = {
-    /**
-     * Name of the attached file
-     */
-    filename: string;
-    /**
-     * Attachment content as string or Buffer
-     */
-    content?: string | Buffer;
-    /**
-     * Path to file to attach
-     */
-    path?: string;
-    /**
-     * Content type (MIME type) of the attachment
-     */
-    contentType?: string;
-};
-/**
- * Options for sending an email with a template
- * Omits html and text as they will be generated from the template
- */
-type TemplateMailOptions = Omit<MailOptions, "html" | "text"> & {
-    /**
-     * Template string to render or path to template file
-     */
-    template: string;
-    /**
-     * Data to pass to the template for rendering
-     */
-    data: Record<string, unknown>;
-    /**
-     * Whether the template is a file path
-     */
-    isFilePath?: boolean;
-};
-/**
- * Interface for template adapters
- * Implement this to create custom template engines
- */
-interface TemplateAdapter {
-    /**
-     * Render a template string with data
-     * @param template - The template string to render
-     * @param data - Data to interpolate into the template
-     * @returns Rendered HTML string (can be sync or async)
-     */
-    render(template: string, data: Record<string, unknown>): Promise<string> | string;
-    /**
-     * Render a template from a file
-     * @param templatePath - Path to the template file
-     * @param data - Data to interpolate into the template
-     * @returns Promise resolving to rendered HTML string
-     */
-    renderFromFile(templatePath: string, data: Record<string, unknown>): Promise<string>;
-}
-/**
- * Interface for mail provider instances
- */
-interface MailProviderInterface {
-    /**
-     * Send an email using builder callback
-     * @param builderFn - Callback function that receives and configures the mail options builder
-     */
-    send(builderFn: (builder: MailOptionsBuilder) => MailOptionsBuilder | void): Promise<void>;
-    /**
-     * Verify the mail provider connection
-     * @returns Promise resolving to true if connection is valid
-     */
-    verify(): Promise<boolean>;
-}
-/**
- * Configuration options for a mail provider
- */
-type MailProviderOptions = {
-    /**
-     * Nodemailer transporter instance
-     */
-    transporter: Transporter;
-    /**
-     * Optional template adapter for rendering email templates
-     */
-    templateAdapter?: TemplateAdapter;
-    /**
-     * Default sender email address for this provider
-     */
-    from?: Email;
-};
-/**
- * Map of provider names to their configuration options
- */
-type MailerProviderOptions = Record<string, MailProviderOptions>;
-/**
- * Configuration options for the Mailer instance
- */
-type MailerOptions<T extends MailerProviderOptions> = {
-    /**
-     * Name of the default provider to use
-     */
-    defaultProvider: keyof T;
-};
-/**
- * Interface for the main Mailer class
- */
-interface MailerInterface {
-    /**
-     * Switch to a specific mail provider
-     * @param provider - Name of the provider to use
-     * @returns The mail provider instance
-     */
-    use(provider: string): MailProviderInterface;
-    /**
-     * Send an email using the default provider with builder pattern
-     * Automatically infers whether to use template or regular send based on builder configuration
-     * @param builderFn - Callback function that receives and configures the mail options builder
-     */
-    send(builderFn: (builder: MailOptionsBuilder) => MailOptionsBuilder | void): Promise<void>;
-    /**
-     * Defer sending an email with an internal in memory queue
-     * The email will be sent in a second moment, when the queue is processed
-     * @param builderFn - Callback function that receives and configures the mail options builder
-     */
-    later(builderFn: (builder: MailOptionsBuilder) => MailOptionsBuilder | void): Promise<void>;
-    /**
-     * Verify the default provider connection
-     * @returns Promise resolving to true if connection is valid
-     */
-    verify(): Promise<boolean>;
-}
-
-/**
- * Handlebars template adapter
- * Requires: npm install handlebars @types/handlebars
- */
-declare class HandlebarsAdapter implements TemplateAdapter {
-    private handlebars;
-    render(template: string, data: Record<string, unknown>): Promise<string>;
-    renderFromFile(templatePath: string, data: Record<string, unknown>): Promise<string>;
-    /**
-     * Register a helper function
-     */
-    registerHelper(name: string, fn: (...args: unknown[]) => unknown): Promise<void>;
-    /**
-     * Register a partial template
-     */
-    registerPartial(name: string, template: string): Promise<void>;
-    private ensureHandlebars;
-}
-
-/**
- * Edge.js template adapter
- * Requires: npm install edge.js
- */
-declare class EdgeAdapter implements TemplateAdapter {
-    private edge;
-    render(template: string, data: Record<string, unknown>): Promise<string>;
-    renderFromFile(templatePath: string, data: Record<string, unknown>): Promise<string>;
-    /**
-     * Register a global helper
-     */
-    global(name: string, value: unknown): Promise<void>;
-    /**
-     * Register a custom tag
-     */
-    registerTag(tag: unknown): Promise<void>;
-    private ensureEdge;
-}
-
-/**
- * Mustache template adapter
- * Requires: npm install mustache @types/mustache
- */
-declare class MustacheAdapter implements TemplateAdapter {
-    private mustache;
-    private partials;
-    render(template: string, data: Record<string, unknown>): Promise<string>;
-    renderFromFile(templatePath: string, data: Record<string, unknown>): Promise<string>;
-    /**
-     * Register a partial template
-     */
-    registerPartial(name: string, template: string): void;
-    private ensureMustache;
-}
-
-/**
- * EJS template adapter
- * Requires: npm install ejs @types/ejs
- */
-declare class EjsAdapter implements TemplateAdapter {
-    private ejs;
-    private options;
-    constructor(options?: Record<string, unknown>);
-    render(template: string, data: Record<string, unknown>): Promise<string>;
-    renderFromFile(templatePath: string, data: Record<string, unknown>): Promise<string>;
-    private ensureEjs;
-}
-
-/**
- * Custom template adapter example
- * Simple string interpolation with {{variable}} syntax
- *
- * Use this as a base to create your own custom adapter
- */
-declare class CustomAdapter implements TemplateAdapter {
-    private helpers;
-    render(template: string, data: Record<string, unknown>): string;
-    renderFromFile(templatePath: string, data: Record<string, unknown>): Promise<string>;
-    /**
-     * Register a custom helper function
-     * Usage in template: {{name:uppercase}}
-     */
-    registerHelper(name: string, fn: (value: unknown) => string): void;
-}
-
-declare class MailProvider implements MailProviderInterface {
-    private readonly transporter;
-    private readonly templateAdapter?;
-    private readonly defaultFrom?;
-    constructor(options: MailProviderOptions);
-    send(builderFn: (builder: MailOptionsBuilder) => MailOptionsBuilder | void): Promise<void>;
-    private sendDirect;
-    private sendWithTemplate;
-    verify(): Promise<boolean>;
-}
-
-declare class Mailer<T extends MailerProviderOptions> implements MailerInterface {
-    private readonly defaultProvider;
-    private readonly providerMap;
-    private emailQueue;
-    private queueInitialized;
-    constructor(providerOptions: T, mailerOptions: MailerOptions<T>);
-    /**
-     * Use a specific mail provider
-     * @param provider - The provider to use
-     * @returns The mail provider instance
-     */
-    use(provider: keyof T): MailProviderInterface;
-    send(builderFn: (builder: MailOptionsBuilder) => MailOptionsBuilder | void): Promise<void>;
-    later(builderFn: (builder: MailOptionsBuilder) => MailOptionsBuilder | void): Promise<void>;
-    private initializeQueue;
-    private processEmail;
-    verify(): Promise<boolean>;
-    private getDefaultProvider;
-}
-
-declare class BaldaError extends Error {
-    constructor(message: string);
-}
-
-declare class MailerError extends BaldaError {
-    constructor(message: string);
-}
-declare class ProviderNotFoundError extends MailerError {
-    constructor(providerName: string);
-}
-declare class TemplateAdapterNotConfiguredError extends MailerError {
-    constructor();
-}
-declare class InvalidDefaultProviderError extends MailerError {
-    constructor(providerName: string);
-}
-
-/**
- * Base class for all plugins.
- *
- * Plugins are used to extend the functionality of the server.
- *
- * @example
- * ```ts
- * import { Server, BasePlugin } from "balda";
- *
- * export class MyPlugin extends BasePlugin {
- *   async handle(): Promise<ServerRouteMiddleware> {
- *     return async (req, res, next) => {
- *       console.log("My plugin is running");
- *       await next();
- *     };
- *   }
- * }
- *
- * const server = new Server();
- * server.use(new MyPlugin().handle());
- * ```
- *
- * @abstract
- */
-declare abstract class BasePlugin {
-    abstract handle(...args: any[]): Promise<ServerRouteMiddleware>;
-}
-
-/**
- * Compression middleware for gzip compression of response bodies
- *
- * @param options Compression middleware options
- */
-declare const compression: (options?: CompressionOptions) => ServerRouteMiddleware;
-
-/**
- * Cookie middleware for parsing and setting cookies, must be used in order to use the cookie methods on the request and response objects
- *
- * @param options Cookie middleware options
- */
-declare const cookie: (options?: CookieMiddlewareOptions) => ServerRouteMiddleware;
-
-/**
- * CORS plugin
- *
- * ⚠️ SECURITY WARNING: By default, this plugin allows ALL origins ('*').
- * For production environments, explicitly configure allowed origins.
- *
- * @param options CORS options (all optional)
- *
- * @example
- * // Development (permissive)
- * cors()
- *
- * @example
- * // Production (secure)
- * cors({
- *   origin: ['https://example.com', 'https://app.example.com'],
- *   credentials: true
- * })
- */
-declare const cors: (options?: CorsOptions) => ServerRouteMiddleware;
-
-/**
- * Converts an Express middleware to a Balda middleware
- */
-declare function expressMiddleware(expressHandler: RequestHandler, basePath?: string): ServerRouteMiddleware;
-/**
- * Converts an Express handler to a Balda handler
- */
-declare function expressHandler(handler: RequestHandler, basePath?: string): ServerRouteHandler;
-/**
- * Mounts an Express router at a specific base path
- * This extracts all routes from the Express router and registers them with Balda
- */
-declare function mountExpressRouter(basePath: string, expressRouter: Router$1): void;
-/**
- * Creates an Express adapter that provides a use method for mounting Express middleware/routers
- *
- * @example
- * ```ts
- * import AdminJS from 'adminjs'
- * import AdminJSExpress from '@adminjs/express'
- * import { createExpressAdapter } from 'balda'
- *
- * const admin = new AdminJS({...})
- * const adminRouter = AdminJSExpress.buildRouter(admin)
- *
- * const server = new Server()
- * const express = createExpressAdapter(server)
- * express.use('/admin', adminRouter)
- * ```
- */
-declare function createExpressAdapter(server: {
-    use: (...middlewares: ServerRouteMiddleware[]) => void;
-}): {
-    use(pathOrMiddleware: string | RequestHandler | Router$1, maybeMiddleware?: RequestHandler | Router$1): void;
-};
-
-/**
- * Sets common HTTP security headers
- * @param options Helmet options (all optional)
- */
-declare const helmet: (options?: HelmetOptions) => ServerRouteMiddleware;
-
-/**
- * Logs the request and response of the handler, can be set both on a specific route or on a global middleware.
- * @warning Only json objects and strings are logged from the request and response.
- */
-declare const log: (options?: LogOptions) => ServerRouteMiddleware;
-
-/**
- * Method override middleware for supporting HTTP verbs like PUT/DELETE in clients that don't support them
- *
- * @param options Method override middleware options
- */
-declare const methodOverride: (options?: MethodOverrideOptions) => ServerRouteMiddleware;
-
-/**
- * Rate limiter plugin
- * Rate limiter is a plugin that limits the number of requests to a resource.
- * It can be used to protect a resource from abuse.
- * @param keyOptions Rate limiter key options, tells the middleware how to retrieve the key from the request in to discriminate what to rate limit (all optional, defaults to ip)
- * @param storageOptions Rate limiter storage options, tells the middleware how to store the rate limit data (all optional, defaults to memory)
- */
-declare const rateLimiter: (keyOptions?: RateLimiterKeyOptions, storageOptions?: StorageOptions$1) => ServerRouteMiddleware;
-
-/**
- * Session plugin middleware, used to store the session in the request and response objects
- * Uses cookies to send the session id
- * @warning Must be used after the cookie middleware
- * @param options Session options
- * @param options.name The name of the session cookie
- * @param options.ttl The TTL of the session in seconds
- * @param options.store The store to use for the session
- * @param options.cookie The cookie options
- */
-declare const session: (options?: SessionOptions) => ServerRouteMiddleware;
-
-/**
- * Creates a static file serving middleware and registers all routes for the given path
- * @param options - The options for serving static files
- * @param options.source - The file system directory path where the assets are located
- * @param options.path - The URL path where the assets will be served
- * @param swaggerOptions - Optional swagger documentation options
- * @example
- * serveStatic({ source: 'tmp/assets', path: '/assets' }) // Serves from ./tmp/assets at /assets/*
- *
- * @example
- * serveStatic({ source: 'public', path: '/public' }) // Serves from ./public at /public/*
- */
-declare const serveStatic: (options: StaticPluginOptions, swaggerOptions?: SwaggerRouteOptions) => ServerRouteMiddleware;
-declare function getContentType(ext: string): string;
-
-/**
- * Timeout plugin middleware, used to timeout the request if it takes too long
- * It fills the req.timeout property with true if the request times out
- * @param options Timeout options
- * @param options.ms The timeout in milliseconds
- * @param options.status The status code to return if the request times out
- * @param options.message The message to return if the request times out
- */
-declare const timeout: (options: TimeoutOptions) => ServerRouteMiddleware;
-
-/**
- * Trust proxy plugin middleware, used to trust the proxy headers to get the client ip
- * @param options Trust proxy options (all optional)
- * @param options.trust Whether to trust the proxy headers
- * @param options.header The header name to read the client IP chain from
- * @param options.hop The hop to use to get the client IP
- */
-declare const trustProxy: (options?: TrustProxyOptions) => ServerRouteMiddleware;
-
-type PolicyProvider = {
-    [K: string]: (...args: any[]) => Promise<boolean> | boolean;
-};
-type PolicyMetadata = {
-    scope: string;
-    handler: string;
-    manager: PolicyManager<any>;
-};
-type PolicyDecorator<T extends Record<string, PolicyProvider>> = <S extends keyof T & string, H extends keyof T[S] & string>(scope: S, handler: H) => (target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => any;
-
-declare class PolicyManager<T extends Record<string, PolicyProvider>> {
-    private readonly providers;
-    constructor(providers: T);
-    /**
-     * Creates a decorator for the policy manager with typed parameters
-     */
-    createDecorator(): PolicyDecorator<T>;
-    /**
-     * Checks if the user has access to the given scope and handler
-     * @param scope - The scope to check access for
-     * @param handler - The handler to check access for
-     * @param args - The arguments to pass to the handler
-     */
-    canAccess<K extends keyof T, L extends T[K]>(scope: K, handler: keyof L, ...args: Parameters<T[K][keyof T[K]]>): ReturnType<T[K][keyof T[K]]>;
-}
-
-declare const createPolicyDecorator: <T extends Record<string, PolicyProvider>>(manager: PolicyManager<T>) => PolicyDecorator<T>;
-
-/**
- * Singleton main router instance that handles all route registrations inside the balda server
- */
-declare const router: ClientRouter;
-
-export { ARG_SYMBOL, type Attachment, AzureBlobStorageProvider, BaseCron, BaseMqtt, BasePlugin, BaseQueue, type BaseStorageProviderOptions, type BlobStorageProviderOptions, BullMQConfiguration, type BullMQConfigurationOptions, BullMQPubSub, type BunTapOptions, Command, type CommandOptions, CommandRegistry, type CronSchedule, type CronScheduleParams, CronService, CustomAdapter, type CustomQueueConfiguration, type CustomStorageProviderOptions, CustomTypedQueue, type CustomValidationError, type DenoTapOptions, EdgeAdapter, EjsAdapter, type Email, type ExpandedMqttTopics, type ExpressAdapterOptions, type ExpressHandler, type ExpressRouter, type ExtractParams, type FileAllowedMimeType, GraphQL, type GraphQLContext, type GraphQLOptions, type GraphQLResolverFunction, type GraphQLResolverMap, type GraphQLResolverType, type GraphQLResolvers, type GraphQLSchemaInput, type GraphQLTypeDef, HandlebarsAdapter, type HttpMethod, type HttpsOptions, type InferSchemaType, InvalidDefaultProviderError, LocalStorageProvider, type LocalStorageProviderOptions, type LoggerOptions, type MailOptions, MailOptionsBuilder, MailProvider, type MailProviderInterface, type MailProviderOptions, Mailer, MailerError, type MailerInterface, type MailerOptions, type MailerProviderOptions, MemoryPubSub, MockResponse, MockServer, type MockServerOptions, type MqttConnectionOptions, type MqttHandler, type MqttPublishOptions, MqttService, type MqttSubscribeOptions, type MqttSubscription, type MqttTopics, MustacheAdapter, type NextFunction, type NodeHttpClient, type NodeServer, type NodeTapOptions, PGBossConfiguration, type PGBossConfigurationOptions, PGBossPubSub, type PolicyDecorator, PolicyManager, type PolicyMetadata, type PolicyProvider, ProviderNotFoundError, type PublishTopic, 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, type TemplateAdapter, TemplateAdapterNotConfiguredError, type TemplateMailOptions, type TypedHandler, TypedQueue, type TypedRouteMetadata, 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, mailOptions, memoryQueue, methodOverride, middleware, mountExpressRouter, mqtt, patch, pgbossQueue, post, put, rateLimiter, router, serialize, serveStatic, session, setCronGlobalErrorHandler, setMqttGlobalErrorHandler, sqsQueue, timeout, trustProxy, validate };