balda 0.0.3 → 0.0.4

package/lib/index.d.ts

@@ -11,10 +11,11 @@ import { RequestHandler, Router as Router$1, IRouter } from 'express';
 export { ErrorRequestHandler as ExpressErrorMiddleware, RequestHandler as ExpressMiddleware, NextFunction as ExpressNextFunction, Request as ExpressRequest, Response as ExpressResponse } from 'express';
 import * as pino from 'pino';
 import pino__default, { pino as pino$1 } from 'pino';
+import { TSchema } from '@sinclair/typebox';
+import { IClientSubscribeOptions, IClientOptions, IClientPublishOptions, MqttClient } from 'mqtt';
+import { SQSClientConfig, SQSClient } from '@aws-sdk/client-sqs';
 import { Queue, Job } from 'bullmq';
 import { PgBoss } from 'pg-boss';
-import { SQSClient, SQSClientConfig } from '@aws-sdk/client-sqs';
-import { IClientSubscribeOptions, IClientOptions, IClientPublishOptions, MqttClient } from 'mqtt';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { S3Client } from '@aws-sdk/client-s3';
 
@@ -1095,14 +1096,15 @@ type ClientRouter = Omit<Router, "applyGlobalMiddlewaresToAllRoutes" | "addOrUpd
  * The server class that is used to create and manage the server
  */
 declare class Server<H extends NodeHttpClient = NodeHttpClient> implements ServerInterface {
+    readonly _brand: "BaldaServer";
     isListening: boolean;
     isProduction: boolean;
     graphql: GraphQL;
+    readonly serverOptions: ResolvedServerOptions;
     readonly router: ClientRouter;
     private wasInitialized;
     private serverConnector;
     private globalMiddlewares;
-    private serverOptions;
     private controllerImportBlacklistedPaths;
     private notFoundHandler?;
     private readonly nativeEnv;
@@ -1664,6 +1666,10 @@ type ResolvedServerOptions = {
 };
 type ServerErrorHandler = (req: Request$1, 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"
      */
@@ -1689,6 +1695,10 @@ interface ServerInterface {
      * @warning Must be used before `listen` method
      */
     tapOptions?: ServerTapOptions;
+    /**
+     * Server options passed to the constructor
+     */
+    serverOptions: ResolvedServerOptions;
     /**
      * Main singleton router instance of the server
      */
@@ -1963,7 +1973,7 @@ interface SerializeOptions {
     safe?: boolean;
 }
 
-declare const serialize: <T extends ZodType | AjvCompileParams[0]>(schema: T, options?: SerializeOptions) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare const serialize: <T extends ZodType | TSchema | AjvCompileParams[0]>(schema: T, options?: SerializeOptions) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 
 interface CustomValidationError {
     status?: number;
@@ -1971,17 +1981,17 @@ interface CustomValidationError {
 }
 interface ValidationOptions {
     /**
-     * The schema to validate the request body against (Zod schema or OpenAPI schema)
+     * The schema to validate the request body against (Zod, TypeBox, or plain JSON schema)
      */
-    body?: ZodType | AjvCompileParams[0];
+    body?: ZodType | TSchema | AjvCompileParams[0];
     /**
-     * The schema to validate the query parameters against (Zod schema or OpenAPI schema)
+     * The schema to validate the query parameters against (Zod, TypeBox, or plain JSON schema)
      */
-    query?: ZodType | AjvCompileParams[0];
+    query?: ZodType | TSchema | AjvCompileParams[0];
     /**
-     * The schema to validate both body and query against (Zod schema or OpenAPI schema)
+     * The schema to validate both body and query against (Zod, TypeBox, or plain JSON schema)
      */
-    all?: ZodType | AjvCompileParams[0];
+    all?: ZodType | TSchema | AjvCompileParams[0];
     /**
      * Whether to use safe validation (returns original data if validation fails instead of throwing)
      * @default false
@@ -2040,92 +2050,6 @@ declare class CronService {
 }
 declare const setCronGlobalErrorHandler: (globalErrorHandler: (...args: Parameters<(typeof CronService)["globalErrorHandler"]>) => void) => void;
 
-declare class BullMQPubSub implements PubSub<"bullmq"> {
-    private queues;
-    private workers;
-    private bullmqClient;
-    publish<T extends QueueTopicKey>(topic: T, payload: QueueTopic[T], options?: PublishOptions<"bullmq">): Promise<{
-        id: string;
-    }>;
-    subscribe<T extends QueueTopicKey>(topic: T, handler: (payload: QueueTopic[T]) => Promise<void>): Promise<void>;
-    private getQueue;
-    private getBullMQClient;
-}
-
-declare class PGBossPubSub implements PubSub<"pgboss"> {
-    private boss;
-    private createdQueues;
-    publish<T extends QueueTopicKey>(topic: T, payload: QueueTopic[T], options?: PublishOptions<"pgboss">): Promise<{
-        id: string;
-    }>;
-    subscribe<T extends QueueTopicKey>(topic: T, handler: (payload: QueueTopic[T]) => Promise<void>): Promise<void>;
-    private getBoss;
-    private ensureQueue;
-}
-
-declare class SQSPubSub implements PubSub<"sqs"> {
-    private consumers;
-    private client?;
-    private sqsLib;
-    private sqsConsumerLib;
-    publish<T extends QueueTopicKey>(topic: T, payload: QueueTopic[T], options?: PublishOptions<"sqs">): Promise<{
-        id: string;
-    }>;
-    subscribe<T extends QueueTopicKey>(topic: T, handler: (payload: QueueTopic[T]) => Promise<void>): Promise<void>;
-    private getClient;
-    private getSqsLib;
-    private getSqsConsumerLib;
-    private resolveQueueUrl;
-}
-
-type BullMQAddTaskOptions = Parameters<Queue["add"]>[2];
-type PGBossSendOptions = Parameters<PgBoss["send"]>[2];
-type SQSPublishOptions = Parameters<SQSClient["send"]>[0];
-type PublishOptions<T extends QueueProviderKey> = T extends "bullmq" ? BullMQAddTaskOptions : T extends "sqs" ? SQSPublishOptions : T extends "pgboss" ? PGBossSendOptions : never;
-interface QueueTopic {
-}
-type QueueTopicKey = keyof QueueTopic;
-interface PubSub<P extends QueueProviderKey = any> {
-    publish: <T extends QueueTopicKey>(topic: T, payload: QueueTopic[T], options: PublishOptions<P>) => Promise<{
-        id: string;
-    }>;
-    subscribe: <T extends QueueTopicKey>(topic: T, handler: (payload: QueueTopic[T]) => Promise<void>) => Promise<void>;
-}
-interface QueueProvider {
-    bullmq: BullMQPubSub;
-    sqs: SQSPubSub;
-    pgboss: PGBossPubSub;
-}
-type QueueProviderKey = keyof QueueProvider;
-
-/**
- * Decorator to register a queue handler
- * @param provider - The provider to use
- * @param topic - The topic to subscribe to
- * @returns A function to decorate the handler
- */
-declare const queue: {
-    <P extends QueueProviderKey, T extends QueueTopicKey>(provider: P, topic: T): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-    bullmq<T extends QueueTopicKey>(topic: T): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-    sqs<T extends QueueTopicKey>(topic: T): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-    pgboss<T extends QueueTopicKey>(topic: T): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-};
-
-type QueueRegistration = {
-    name: string;
-    topic: QueueTopicKey;
-    handler: (payload: any) => Promise<void>;
-    provider: QueueProviderKey;
-};
-declare class QueueService {
-    static scheduledSubscribers: QueueRegistration[];
-    static register(name: string, topic: QueueRegistration["topic"], handler: QueueRegistration["handler"], options?: {
-        provider?: QueueProviderKey;
-    }): void;
-    static run(): Promise<void>;
-    static massiveImportQueues(queueHandlerPatterns: string[]): Promise<void>;
-}
-
 /**
  * Base class for MQTT handlers with logger instance
  * @example
@@ -2245,8 +2169,10 @@ 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 {
- *   @queue("bullmq", "my-topic")
+ *   @myQueue.subscribe()
  *   async handle(payload: MyPayload) {
  *     this.logger.info({ payload }, "Processing queue message");
  *   }
@@ -2256,6 +2182,89 @@ declare class BaseQueue {
     protected readonly logger: pino.Logger<string, boolean>;
 }
 
+declare class PGBossPubSub implements GenericPubSub {
+    private boss;
+    private createdQueues;
+    publish<TPayload>(topic: string, payload: TPayload, options?: PublishOptions<"pgboss">): Promise<{
+        id: string;
+    }>;
+    subscribe<TPayload>(topic: string, handler: (payload: TPayload) => Promise<void>): 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>;
+    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 = Parameters<Queue["add"]>[2];
+type PGBossSendOptions = Parameters<PgBoss["send"]>[2];
+type SQSPublishOptions = Parameters<SQSClient["send"]>[0];
+type BuiltInProviderKey = "bullmq" | "sqs" | "pgboss";
+type PublishOptions<T extends BuiltInProviderKey> = T extends "bullmq" ? BullMQAddTaskOptions : T extends "sqs" ? SQSPublishOptions : T extends "pgboss" ? PGBossSendOptions : never;
+type SQSQueueOptions = {
+    queueUrl: string;
+    client?: SQSClientConfig;
+};
+type BullMQQueueOptions = ConstructorParameters<typeof Queue>[1];
+type PGBossQueueOptions = {
+    connectionString?: string;
+};
+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>;
+}
+interface QueueProvider {
+    bullmq: BullMQPubSub;
+    sqs: SQSPubSub;
+    pgboss: PGBossPubSub;
+}
+type QueueProviderKey = keyof QueueProvider;
+
+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>;
+    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;
+}
+
 /**
  * Options for BullMQ configuration
  * @param options - The options for BullMQ
@@ -2273,7 +2282,7 @@ declare class BullMQConfiguration {
  */
 declare const defineBullMQConfiguration: (options: BullMQConfigurationOptions) => void;
 
-type CustomQueueConfiguration = PubSub;
+type CustomQueueConfiguration = GenericPubSub;
 
 type PGBossConfigurationOptions = {
     connectionString?: string;
@@ -2291,7 +2300,7 @@ type SQSConfigurationOptions = {
         batchSize?: number;
         visibilityTimeout?: number;
         waitTimeSeconds?: number;
-        queueUrlMap: Record<QueueTopicKey, string>;
+        queueUrlMap: Record<string, string>;
     };
     errorHandler?: (error: Error) => SyncOrAsync;
 };
@@ -2300,33 +2309,10 @@ declare class SQSConfiguration {
 }
 declare const defineSQSConfiguration: (options: SQSConfigurationOptions) => void;
 
-/**
- * Main publisher for balda queue, has shortcuts for base providers, e.g. `publish.bullmq`
- * @param provider - The provider to use
- * @param topic - The topic to publish to
- * @param payload - The payload to publish
- * @param options - The options to use
- * @returns The id of the published job
- */
-declare const publish: {
-    <P extends QueueProviderKey, T extends QueueTopicKey>(provider: P, topic: T, payload: QueueTopic[T], options?: PublishOptions<P>): Promise<{
-        id: string;
-    }>;
-    bullmq<T extends QueueTopicKey>(topic: T, payload: QueueTopic[T], options?: PublishOptions<"bullmq">): Promise<{
-        id: string;
-    }>;
-    sqs<T extends QueueTopicKey>(topic: T, payload: QueueTopic[T], options?: PublishOptions<"sqs">): Promise<{
-        id: string;
-    }>;
-    pgboss<T extends QueueTopicKey>(topic: T, payload: QueueTopic[T], options?: PublishOptions<"pgboss">): Promise<{
-        id: string;
-    }>;
-};
-
 declare class QueueManager {
-    static map: Map<QueueProviderKey, PubSub>;
-    static getProvider<P extends QueueProviderKey>(provider: P): PubSub<P>;
-    static setProvider(provider: QueueProviderKey, pubsub: PubSub<QueueProviderKey>): void;
+    static map: Map<QueueProviderKey, GenericPubSub>;
+    static getProvider<P extends QueueProviderKey>(provider: P): GenericPubSub<P>;
+    static setProvider(provider: QueueProviderKey, pubsub: GenericPubSub<QueueProviderKey>): void;
 }
 
 /**
@@ -2364,6 +2350,187 @@ declare const defineQueueConfiguration: (options: {
     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>;
+}
+
+type QueueOptionsForProvider<P extends BuiltInProviderKey> = P extends "sqs" ? SQSQueueOptions : P extends "bullmq" ? BullMQQueueOptions : P extends "pgboss" ? PGBossQueueOptions : 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 to subscribe to the queue
+     * @example
+     * ```ts
+     * @queue.subscribe(async (payload: TPayload) => {
+     *   console.log(payload);
+     * })
+     * ```
+     */
+    subscribe(handler: (payload: TPayload) => Promise<void>): 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>;
+    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 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>;
+
 /**
  * The logger instance, can be overridden by the `defineLoggerConfig` function
  */
@@ -2542,7 +2709,7 @@ declare class GenerateSdkCommand extends Command {
     static help: string[];
     static serverPath: string;
     static outputPath: string;
-    static swaggerPath: string;
+    static swaggerPath?: string;
     static httpClient: string;
     static unwrapResponseData: boolean;
     static singleHttpClient: boolean;
@@ -3091,4 +3258,4 @@ declare const createPolicyDecorator: <T extends Record<string, PolicyProvider>>(
  */
 declare const router: ClientRouter;
 
-export { ARG_SYMBOL, AzureBlobStorageProvider, BaseCron, BaseMqtt, BasePlugin, BaseQueue, type BaseStorageProviderOptions, type BlobStorageProviderOptions, BullMQConfiguration, type BullMQConfigurationOptions, BullMQPubSub, type BunTapOptions, Command, type CommandOptions, CommandRegistry, type CronSchedule, type CronScheduleParams, CronService, type CustomQueueConfiguration, type CustomStorageProviderOptions, type CustomValidationError, type DenoTapOptions, type ExpressAdapterOptions, type ExpressHandler, type ExpressRouter, type FileAllowedMimeType, GraphQL, type GraphQLContext, type GraphQLOptions, type GraphQLResolverFunction, type GraphQLResolverMap, type GraphQLResolverType, type GraphQLResolvers, type GraphQLSchemaInput, type GraphQLTypeDef, type HttpMethod, type HttpsOptions, LocalStorageProvider, type LocalStorageProviderOptions, type LoggerOptions, MockServer, type MockServerOptions, type MqttConnectionOptions, type MqttHandler, type MqttPublishOptions, MqttService, type MqttSubscribeOptions, type MqttSubscription, type MqttTopics, type NextFunction, type NodeHttpClient, type NodeServer, type NodeTapOptions, PGBossConfiguration, type PGBossConfigurationOptions, PGBossPubSub, type PGBossSendOptions, type PolicyDecorator, PolicyManager, type PolicyMetadata, type PolicyProvider, type PubSub, type PublishOptions, QueueManager, type QueueProvider, type QueueProviderKey, QueueService, type QueueTopic, type QueueTopicKey, Request$1 as Request, type ResolvedServerOptions, Response$1 as Response, type ReturnType$1 as ReturnType, type ReturnTypeMap, type RuntimeServer, type RuntimeServerMap, S3StorageProvider, type S3StorageProviderOptions, SQSConfiguration, type SQSConfigurationOptions, SQSPubSub, type SQSPublishOptions, type SerializeOptions, Server, type ServerConnectInput, type ServerErrorHandler, type ServerInterface, type ServerListenCallback, type ServerOptions, type ServerPlugin, type ServerRoute, type ServerRouteHandler, type ServerRouteMiddleware, type ServerTapOptions, type ServerTapOptionsBuilder, type SignalEvent, type StandardMethodOptions, type StaticPluginOptions, Storage, type StorageInterface, type StorageOptions, type StorageProviderOptions, VALIDATION_ERROR_SYMBOL, type ValidationOptions, arg, asyncLocalStorage, asyncStorage, baseCommands, commandRegistry, compression, controller, cookie, cors, createExpressAdapter, createPolicyDecorator, cron, defineLoggerConfig, defineQueueConfiguration, del, expressHandler, expressMiddleware, fileParser, flag, get, getContentType, hash, helmet, json, log, logger, methodOverride, middleware, mountExpressRouter, mqtt, patch, post, publish, put, queue, rateLimiter, router, serialize, serveStatic, session, setCronGlobalErrorHandler, setMqttGlobalErrorHandler, timeout, trustProxy, urlencoded, validate };
+export { ARG_SYMBOL, AzureBlobStorageProvider, BaseCron, BaseMqtt, BasePlugin, BaseQueue, type BaseStorageProviderOptions, type BlobStorageProviderOptions, BullMQConfiguration, type BullMQConfigurationOptions, BullMQPubSub, type BunTapOptions, Command, type CommandOptions, CommandRegistry, type CronSchedule, type CronScheduleParams, CronService, type CustomQueueConfiguration, type CustomStorageProviderOptions, CustomTypedQueue, type CustomValidationError, type DenoTapOptions, type ExpressAdapterOptions, type ExpressHandler, type ExpressRouter, type FileAllowedMimeType, GraphQL, type GraphQLContext, type GraphQLOptions, type GraphQLResolverFunction, type GraphQLResolverMap, type GraphQLResolverType, type GraphQLResolvers, type GraphQLSchemaInput, type GraphQLTypeDef, type HttpMethod, type HttpsOptions, LocalStorageProvider, type LocalStorageProviderOptions, type LoggerOptions, MockServer, type MockServerOptions, type MqttConnectionOptions, type MqttHandler, type MqttPublishOptions, MqttService, type MqttSubscribeOptions, type MqttSubscription, type MqttTopics, type NextFunction, type NodeHttpClient, type NodeServer, type NodeTapOptions, PGBossConfiguration, type PGBossConfigurationOptions, PGBossPubSub, type PolicyDecorator, PolicyManager, type PolicyMetadata, type PolicyProvider, QueueManager, QueueService, Request$1 as Request, type ResolvedServerOptions, Response$1 as Response, type ReturnType$1 as ReturnType, type ReturnTypeMap, type RuntimeServer, type RuntimeServerMap, S3StorageProvider, type S3StorageProviderOptions, SQSConfiguration, type SQSConfigurationOptions, SQSPubSub, type SerializeOptions, Server, type ServerConnectInput, type ServerErrorHandler, type ServerInterface, type ServerListenCallback, type ServerOptions, type ServerPlugin, type ServerRoute, type ServerRouteHandler, type ServerRouteMiddleware, type ServerTapOptions, type ServerTapOptionsBuilder, type SignalEvent, type StandardMethodOptions, type StaticPluginOptions, Storage, type StorageInterface, type StorageOptions, type StorageProviderOptions, TypedQueue, VALIDATION_ERROR_SYMBOL, type ValidationOptions, arg, asyncLocalStorage, asyncStorage, baseCommands, bullmqQueue, commandRegistry, compression, controller, cookie, cors, createExpressAdapter, createPolicyDecorator, createQueue, cron, defineLoggerConfig, defineQueueConfiguration, del, expressHandler, expressMiddleware, fileParser, flag, get, getContentType, hash, helmet, json, log, logger, methodOverride, middleware, mountExpressRouter, mqtt, patch, pgbossQueue, post, put, rateLimiter, router, serialize, serveStatic, session, setCronGlobalErrorHandler, setMqttGlobalErrorHandler, sqsQueue, timeout, trustProxy, urlencoded, validate };