@vercel/queue 0.0.0-alpha.1 → 0.0.0-alpha.11

package/dist/index.d.mts

@@ -44,7 +44,7 @@ declare class BufferTransport implements Transport<Buffer> {
  *
  * IMPORTANT: When using StreamTransport, you must call finalize(payload) when done
  * processing the message to prevent resource leaks, especially in error cases.
- * ConsumerGroup handles this automatically, but direct VQSClient usage requires manual cleanup.
+ * ConsumerGroup handles this automatically, but direct QueueClient usage requires manual cleanup.
  *
  * Example usage:
  * ```typescript
@@ -71,44 +71,10 @@ declare class StreamTransport implements Transport<ReadableStream<Uint8Array>> {
  * Vercel Queue Service client types
  */
 
-interface VQSClientOptions {
-    /**
-     * Base URL for the Vercel Queue Service API
-     * @default "https://vqs.vercel.sh"
-     */
-    baseUrl?: string;
-    /**
-     * Vercel function OIDC token
-     * Can be obtained from x-vercel-oidc-token header in Vercel Serverless Functions
-     */
-    token: string;
-}
 /**
- * Callback configuration for a consumer group
+ * Shared options for publishing messages
  */
-interface CallbackConfig {
-    /**
-     * Webhook URL to notify when messages are available
-     */
-    url: string;
-    /**
-     * Delay in seconds before sending the first callback
-     */
-    delay?: number;
-    /**
-     * Delay in seconds between retry attempts when the callback fails
-     */
-    frequency?: number;
-}
-interface SendMessageOptions<T = unknown> {
-    /**
-     * The queue name to send the message to
-     */
-    queueName: string;
-    /**
-     * The message payload
-     */
-    payload: T;
+interface PublishOptions {
     /**
      * Unique key to prevent duplicate message submissions
      * @default random UUID
@@ -121,11 +87,16 @@ interface SendMessageOptions<T = unknown> {
      * @max 86400
      */
     retentionSeconds?: number;
+}
+interface SendMessageOptions<T = unknown> extends PublishOptions {
+    /**
+     * The queue name to send the message to
+     */
+    queueName: string;
     /**
-     * Consumer group callback configurations
-     * Format: { consumerGroup: { url, delay?, frequency? } }
+     * The message payload
      */
-    callbacks?: Record<string, CallbackConfig>;
+    payload: T;
 }
 interface SendMessageResponse {
     /**
@@ -149,9 +120,9 @@ interface Message<T = unknown> {
      */
     deliveryCount: number;
     /**
-     * Timestamp when the message was created
+     * When the message was created
      */
-    timestamp: string;
+    createdAt: Date;
     /**
      * MIME type of the message content
      */
@@ -161,80 +132,6 @@ interface Message<T = unknown> {
      */
     ticket: string;
 }
-interface ReceiveMessagesOptions<T = unknown> {
-    /**
-     * The queue name to receive messages from
-     */
-    queueName: string;
-    /**
-     * Consumer group name
-     */
-    consumerGroup: string;
-    /**
-     * Time in seconds that messages will be invisible to other consumers
-     * @default 900 (15 minutes)
-     */
-    visibilityTimeoutSeconds?: number;
-    /**
-     * Maximum number of messages to retrieve
-     * @default 10
-     * @max 10
-     * @note FIFO queues must use limit=1
-     */
-    limit?: number;
-}
-interface DeleteMessageOptions {
-    /**
-     * The queue name the message belongs to
-     */
-    queueName: string;
-    /**
-     * Consumer group name
-     */
-    consumerGroup: string;
-    /**
-     * The message ID to delete
-     */
-    messageId: string;
-    /**
-     * Ticket received from the message
-     */
-    ticket: string;
-}
-interface DeleteMessageResponse {
-    /**
-     * Whether the message was successfully deleted
-     */
-    deleted: boolean;
-}
-interface ChangeVisibilityOptions {
-    /**
-     * The queue name the message belongs to
-     */
-    queueName: string;
-    /**
-     * Consumer group name
-     */
-    consumerGroup: string;
-    /**
-     * The message ID to update
-     */
-    messageId: string;
-    /**
-     * Ticket received from the message
-     */
-    ticket: string;
-    /**
-     * New visibility timeout in seconds
-     */
-    visibilityTimeoutSeconds: number;
-}
-interface ChangeVisibilityResponse {
-    /**
-     * Whether the visibility was successfully updated
-     */
-    updated: boolean;
-}
 /**
  * Result indicating the message should be timed out for retry later
  */
@@ -248,10 +145,18 @@ interface MessageTimeoutResult {
  * Result returned by message handlers
  */
 type MessageHandlerResult = void | MessageTimeoutResult;
+/**
+ * Message metadata provided to handlers
+ */
+interface MessageMetadata {
+    messageId: string;
+    deliveryCount: number;
+    createdAt: Date;
+}
 /**
  * Message handler function type
  */
-type MessageHandler<T = unknown> = (message: Message<T>) => Promise<MessageHandlerResult> | MessageHandlerResult;
+type MessageHandler<T = unknown> = (message: T, metadata: MessageMetadata) => Promise<MessageHandlerResult> | MessageHandlerResult;
 /**
  * Options for creating a ConsumerGroup instance
  */
@@ -272,44 +177,6 @@ interface ConsumerGroupOptions<T = unknown> {
      */
     refreshInterval?: number;
 }
-interface ReceiveMessageByIdOptions<T = unknown> {
-    /**
-     * The queue name to receive the message from
-     */
-    queueName: string;
-    /**
-     * Consumer group name
-     */
-    consumerGroup: string;
-    /**
-     * The message ID to retrieve
-     */
-    messageId: string;
-    /**
-     * Time in seconds that the message will be invisible to other consumers
-     * @default 900 (15 minutes)
-     */
-    visibilityTimeoutSeconds?: number;
-    /**
-     * Skip payload content and only return message metadata
-     * When true, the server returns a 204 status with headers containing message metadata
-     * @default false
-     */
-    skipPayload?: boolean;
-}
-interface ReceiveMessageByIdResponse<T = unknown, TSkipPayload extends boolean = false> {
-    message: TSkipPayload extends true ? Message<void> : Message<T>;
-}
-interface FifoOrderingError {
-    /**
-     * Error message describing the FIFO ordering violation
-     */
-    error: string;
-    /**
-     * The message ID that must be processed first
-     */
-    nextMessageId: string;
-}
 /**
  * Error thrown when a message is not found (404)
  */
@@ -323,13 +190,6 @@ declare class MessageNotFoundError extends Error {
 declare class MessageNotAvailableError extends Error {
     constructor(messageId: string, reason?: string);
 }
-/**
- * Error thrown when there's a FIFO ordering violation (409 with nextMessageId)
- */
-declare class FifoOrderingViolationError extends Error {
-    readonly nextMessageId: string;
-    constructor(messageId: string, nextMessageId: string, reason: string);
-}
 /**
  * Error thrown when message data is corrupted or can't be parsed
  */
@@ -343,7 +203,7 @@ declare class QueueEmptyError extends Error {
     constructor(queueName: string, consumerGroup: string);
 }
 /**
- * Error thrown when a message is temporarily locked in a FIFO queue (423)
+ * Error thrown when a message is temporarily locked (423)
  */
 declare class MessageLockedError extends Error {
     readonly retryAfter?: number;
@@ -367,13 +227,6 @@ declare class ForbiddenError extends Error {
 declare class BadRequestError extends Error {
     constructor(message: string);
 }
-/**
- * Error thrown when there's a failed dependency (424) - FIFO ordering violation in receive by ID
- */
-declare class FailedDependencyError extends Error {
-    readonly nextMessageId: string;
-    constructor(messageId: string, nextMessageId: string);
-}
 /**
  * Error thrown for internal server errors (500)
  */
@@ -386,340 +239,124 @@ declare class InternalServerError extends Error {
 declare class InvalidLimitError extends Error {
     constructor(limit: number, min?: number, max?: number);
 }
+
 /**
- * Options extracted from a VQS callback request
- */
-interface CallbackMessageOptions {
-    /**
-     * The queue name extracted from Vqs-Queue-Name header
-     */
-    queueName: string;
-    /**
-     * The consumer group extracted from Vqs-Consumer-Group header
-     */
-    consumerGroup: string;
-    /**
-     * The message ID extracted from Vqs-Message-Id header
-     */
-    messageId: string;
-}
-/**
- * Error thrown when VQS callback headers are missing or invalid
+ * Options for the consume method
  */
-declare class InvalidCallbackError extends Error {
-    constructor(message: string);
+interface ConsumeOptions {
+    /** The specific message ID to consume (if not provided, consumes next available message) */
+    messageId?: string;
+    /** Whether to skip downloading the payload (only allowed when messageId is provided) */
+    skipPayload?: boolean;
 }
 
 /**
- * Client for interacting with the Vercel Queue Service API
+ * Options for the send function
  */
-declare class VQSClient {
-    private baseUrl;
-    private token;
-    /**
-     * Create a new Vercel Queue Service client
-     * @param options Client configuration options
-     */
-    constructor(options: VQSClientOptions);
-    /**
-     * Create a VQSClient automatically configured for Vercel Functions
-     * This method automatically retrieves the OIDC token from the Vercel Function environment
-     * Always creates a fresh instance since OIDC tokens expire after 15 minutes
-     * @param baseUrl Optional base URL override
-     * @returns Promise resolving to a new VQSClient instance
-     */
-    static fromVercelFunction(baseUrl?: string): Promise<VQSClient>;
-    /**
-     * Send a message to a queue
-     * @param options Send message options
-     * @param transport Serializer/deserializer for the payload
-     * @returns Promise with the message ID
-     * @throws {BadRequestError} When request parameters are invalid
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied (environment mismatch)
-     * @throws {InternalServerError} When server encounters an error
-     */
-    sendMessage<T = unknown>(options: SendMessageOptions<T>, transport: Transport<T>): Promise<SendMessageResponse>;
-    /**
-     * Receive messages from a queue
-     * @param options Receive messages options
-     * @param transport Serializer/deserializer for the payload
-     * @returns AsyncGenerator that yields messages as they arrive
-     * @throws {InvalidLimitError} When limit parameter is not between 1 and 10
-     * @throws {QueueEmptyError} When no messages are available (204)
-     * @throws {MessageLockedError} When FIFO queue has locked messages (423)
-     * @throws {BadRequestError} When request parameters are invalid
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied (environment mismatch)
-     * @throws {InternalServerError} When server encounters an error
-     */
-    receiveMessages<T = unknown>(options: ReceiveMessagesOptions<T>, transport: Transport<T>): AsyncGenerator<Message<T>, void, unknown>;
-    /**
-     * Receive a specific message by its ID from a queue
-     * @param options Receive message by ID options
-     * @param transport Serializer/deserializer for the payload
-     * @returns Promise with the message or null if not found/available
-     * @throws {MessageNotFoundError} When the message doesn't exist (404)
-     * @throws {MessageLockedError} When the message is temporarily locked (423)
-     * @throws {FailedDependencyError} When FIFO ordering is violated (424)
-     * @throws {MessageNotAvailableError} When message exists but isn't available (409)
-     * @throws {FifoOrderingViolationError} When FIFO ordering is violated (409 with nextMessageId)
-     * @throws {MessageCorruptedError} When message data is corrupted
-     * @throws {BadRequestError} When request parameters are invalid
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied (environment mismatch)
-     * @throws {InternalServerError} When server encounters an error
-     */
-    receiveMessageById<T = unknown>(options: ReceiveMessageByIdOptions<T> & {
-        skipPayload: true;
-    }, transport?: Transport<T>): Promise<ReceiveMessageByIdResponse<T, true>>;
-    receiveMessageById<T = unknown>(options: ReceiveMessageByIdOptions<T> & {
-        skipPayload?: false | undefined;
-    }, transport: Transport<T>): Promise<ReceiveMessageByIdResponse<T, false>>;
+interface SendOptions<T = unknown> extends PublishOptions {
     /**
-     * Delete a message (acknowledge processing)
-     * @param options Delete message options
-     * @returns Promise with delete status
-     * @throws {MessageNotFoundError} When the message doesn't exist (404)
-     * @throws {MessageNotAvailableError} When message can't be deleted (409)
-     * @throws {BadRequestError} When ticket is missing or invalid (400)
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied (environment mismatch)
-     * @throws {InternalServerError} When server encounters an error
-     */
-    deleteMessage(options: DeleteMessageOptions): Promise<DeleteMessageResponse>;
-    /**
-     * Change the visibility timeout of a message
-     * @param options Change visibility options
-     * @returns Promise with update status
-     * @throws {MessageNotFoundError} When the message doesn't exist (404)
-     * @throws {MessageNotAvailableError} When message can't be updated (409)
-     * @throws {BadRequestError} When ticket is missing or visibility timeout invalid (400)
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied (environment mismatch)
-     * @throws {InternalServerError} When server encounters an error
+     * Serializer/deserializer for the payload
+     * @default JsonTransport instance
      */
-    changeVisibility(options: ChangeVisibilityOptions): Promise<ChangeVisibilityResponse>;
+    transport?: Transport<T>;
 }
-
 /**
- * A ConsumerGroup represents a named group of consumers that process messages from a topic
+ * Send a message to a topic (shorthand for topic creation and publishing)
+ * Uses the default QueueClient with automatic OIDC token detection
+ * @param topicName Name of the topic to send to
+ * @param payload The data to send
+ * @param options Optional send options including transport and publish settings
+ * @returns Promise with the message ID
+ * @throws {BadRequestError} When request parameters are invalid
+ * @throws {UnauthorizedError} When authentication fails
+ * @throws {ForbiddenError} When access is denied (environment mismatch)
+ * @throws {InternalServerError} When server encounters an error
  */
-declare class ConsumerGroup<T = unknown> {
-    private client;
-    private topicName;
-    private consumerGroupName;
-    private visibilityTimeout;
-    private refreshInterval;
-    private transport;
-    /**
-     * Create a new ConsumerGroup instance
-     * @param client VQSClient instance to use for API calls
-     * @param topicName Name of the topic to consume from
-     * @param consumerGroupName Name of the consumer group
-     * @param options Optional configuration
-     */
-    constructor(client: VQSClient, topicName: string, consumerGroupName: string, options?: ConsumerGroupOptions<T>);
-    /**
-     * Starts a background loop that periodically extends the visibility timeout for a message.
-     * This prevents the message from becoming visible to other consumers while it's being processed.
-     *
-     * The extension loop runs every `refreshInterval` seconds and updates the message's
-     * visibility timeout to `visibilityTimeout` seconds from the current time.
-     *
-     * @param messageId - The unique identifier of the message to extend visibility for
-     * @param ticket - The receipt ticket that proves ownership of the message
-     * @returns A function that when called will stop the extension loop
-     *
-     * @remarks
-     * - The first extension attempt occurs after `refreshInterval` seconds, not immediately
-     * - If an extension fails, the loop terminates with an error logged to console
-     * - The returned stop function is idempotent - calling it multiple times is safe
-     * - By default, the stop function returns immediately without waiting for in-flight
-     * - Pass `true` to the stop function to wait for any in-flight extension to complete
-     */
-    private startVisibilityExtension;
-    /**
-     * Process a single message with the given handler
-     * @param message The message to process
-     * @param handler Function to process the message
-     */
-    private processMessage;
-    /**
-     * Start continuous processing of messages from the topic
-     * @param signal AbortSignal to control when to stop processing
-     * @param handler Function to process each message
-     * @param options Processing options
-     * @returns Promise that resolves when processing stops (due to signal or error)
-     */
-    subscribe(signal: AbortSignal, handler: MessageHandler<T>, options?: {
-        pollingInterval?: number;
-    }): Promise<void>;
-    /**
-     * Receive and process a specific message by its ID with full payload
-     * @param messageId The ID of the message to receive and process
-     * @param handler Function to process the message with full payload
-     * @returns Promise that resolves when the message is processed or rejects with specific errors
-     * @throws {MessageNotFoundError} When the message doesn't exist (404)
-     * @throws {MessageNotAvailableError} When the message exists but isn't available for processing (409)
-     * @throws {MessageLockedError} When the message is temporarily locked (423)
-     * @throws {FifoOrderingViolationError} When there's a FIFO ordering violation (409 with nextMessageId)
-     * @throws {FailedDependencyError} When FIFO ordering is violated (424)
-     * @throws {MessageCorruptedError} When the message data is corrupted
-     * @throws {BadRequestError} When request parameters are invalid
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied
-     * @throws {InternalServerError} When server encounters an error
-     */
-    receiveMessage(messageId: string, handler: MessageHandler<T>): Promise<void>;
-    /**
-     * Receive and process the next available message from the queue
-     * @param handler Function to process the message
-     * @returns Promise that resolves when the message is processed or rejects with specific errors
-     * @throws {QueueEmptyError} When no messages are available in the queue (204)
-     * @throws {MessageLockedError} When the next message in a FIFO queue is locked (423)
-     * @throws {BadRequestError} When request parameters are invalid
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied
-     * @throws {InternalServerError} When server encounters an error
-     */
-    receiveNextMessage(handler: MessageHandler<T>): Promise<void>;
-    /**
-     * Receive and process multiple next available messages from the queue
-     * @param limit Number of messages to process (1-10)
-     * @param handler Function to process each message
-     * @returns Promise that resolves to an array of PromiseSettledResult (same as Promise.allSettled)
-     * @throws {InvalidLimitError} When limit parameter is not between 1 and 10
-     * @throws {QueueEmptyError} When no messages are available in the queue (204)
-     * @throws {MessageLockedError} When the next message in a FIFO queue is locked (423)
-     * @throws {BadRequestError} When request parameters are invalid
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied
-     * @throws {InternalServerError} When server encounters an error
-     */
-    receiveNextMessages(limit: number, handler: MessageHandler<T>): Promise<PromiseSettledResult<void>[]>;
-    /**
-     * Handle a specific message by its ID without downloading the payload (metadata only)
-     * @param messageId The ID of the message to handle
-     * @param handler Function to process the message metadata (payload will be void)
-     * @returns Promise that resolves when the message is handled or rejects with specific errors
-     * @throws {MessageNotFoundError} When the message doesn't exist (404)
-     * @throws {MessageNotAvailableError} When the message exists but isn't available for processing (409)
-     * @throws {MessageLockedError} When the message is temporarily locked (423)
-     * @throws {FifoOrderingViolationError} When there's a FIFO ordering violation (409 with nextMessageId)
-     * @throws {FailedDependencyError} When FIFO ordering is violated (424)
-     * @throws {MessageCorruptedError} When the message data is corrupted
-     * @throws {BadRequestError} When request parameters are invalid
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied
-     * @throws {InternalServerError} When server encounters an error
-     */
-    handleMessage(messageId: string, handler: MessageHandler<void>): Promise<void>;
-    /**
-     * Get the consumer group name
-     */
-    get name(): string;
-    /**
-     * Get the topic name this consumer group is subscribed to
-     */
-    get topic(): string;
-}
-
+declare function send<T = unknown>(topicName: string, payload: T, options?: SendOptions<T>): Promise<{
+    messageId: string;
+}>;
 /**
- * A Topic represents a named channel for publishing messages in a pub/sub pattern
+ * Options for the receive function
  */
-declare class Topic<T = unknown> {
-    private client;
-    private topicName;
-    private transport;
-    /**
-     * Create a new Topic instance
-     * @param client VQSClient instance to use for API calls
-     * @param topicName Name of the topic to work with
-     * @param transport Optional serializer/deserializer for the payload (defaults to JSON)
-     */
-    constructor(client: VQSClient, topicName: string, transport?: Transport<T>);
-    /**
-     * Publish a message to the topic
-     * @param payload The data to publish
-     * @param options Optional publish options
-     * @returns An object containing the message ID
-     * @throws {BadRequestError} When request parameters are invalid
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied (environment mismatch)
-     * @throws {InternalServerError} When server encounters an error
-     */
-    publish(payload: T, options?: {
-        idempotencyKey?: string;
-        retentionSeconds?: number;
-        callbacks?: Record<string, CallbackConfig>;
-    }): Promise<{
-        messageId: string;
-    }>;
-    /**
-     * Create a consumer group for this topic
-     * @param consumerGroupName Name of the consumer group
-     * @param options Optional configuration for the consumer group
-     * @returns A ConsumerGroup instance
-     */
-    consumerGroup<U = T>(consumerGroupName: string, options?: ConsumerGroupOptions<U>): ConsumerGroup<U>;
-    /**
-     * Get the topic name
-     */
-    get name(): string;
-    /**
-     * Get the transport used by this topic
-     */
-    get serializer(): Transport<T>;
+interface ReceiveOptions<T = unknown> extends ConsumerGroupOptions<T>, ConsumeOptions {
 }
-
 /**
- * Create a new Topic instance
- * @param client VQSClient instance to use for API calls
- * @param topicName Name of the topic
- * @param transport Optional serializer/deserializer for the payload (defaults to JSON)
- * @returns A Topic instance
+ * Receive a message from a topic (shorthand for topic and consumer group creation)
+ * Uses the default QueueClient with automatic OIDC token detection
+ * @param topicName Name of the topic to receive from
+ * @param consumerGroup Name of the consumer group
+ * @param handler Function to process the message
+ * @returns Promise that resolves when the message is processed
+ * @throws All the same errors as the underlying client methods
  */
-declare function createTopic<T = unknown>(client: VQSClient, topicName: string, transport?: Transport<T>): Topic<T>;
-
+declare function receive<T = unknown>(topicName: string, consumerGroup: string, handler: MessageHandler<T>, options?: ReceiveOptions<T>): Promise<void>;
+/**
+ * Receive a specific message by its ID with full payload
+ * @param topicName Name of the topic to receive from
+ * @param consumerGroup Name of the consumer group
+ * @param handler Function to process the message
+ * @param options Receive options with messageId specified
+ * @returns Promise that resolves when the message is processed
+ * @throws All the same errors as the underlying client methods
+ */
+declare function receive<T = unknown>(topicName: string, consumerGroup: string, handler: MessageHandler<T>, options: ReceiveOptions<T> & {
+    messageId: string;
+    skipPayload?: false | undefined;
+}): Promise<void>;
 /**
- * VQS Callback utilities for handling incoming webhook payloads
+ * Receive a specific message by its ID without downloading the payload (metadata only)
+ * @param topicName Name of the topic to receive from
+ * @param consumerGroup Name of the consumer group
+ * @param handler Function to process the message metadata (payload will be void)
+ * @param options Receive options with messageId and skipPayload specified
+ * @returns Promise that resolves when the message is processed
+ * @throws All the same errors as the underlying client methods
  */
+declare function receive<T = unknown>(topicName: string, consumerGroup: string, handler: MessageHandler<void>, options: ReceiveOptions<T> & {
+    messageId: string;
+    skipPayload: true;
+}): Promise<void>;
 
 /**
- * Parse a VQS callback request and extract the required information for receiveMessageById
+ * Configuration object with handlers for different topics and consumer groups
+ */
+type CallbackHandlers = {
+    [topicName: string]: {
+        [consumerGroup: string]: MessageHandler;
+    };
+};
+/**
+ * Simplified queue callback handler for Next.js route handlers
+ *
+ * Automatically extracts queue information from CloudEvent format
+ * and routes to the appropriate handler based on topic and consumer group.
  *
- * @param request The incoming Request object from the VQS callback
- * @returns CallbackMessageOptions that can be used with receiveMessageById
- * @throws {InvalidCallbackError} When required VQS headers are missing or invalid
+ * @param handlers Object with topic-specific handlers organized by consumer groups
+ * @returns A Next.js route handler function
  *
  * @example
  * ```typescript
- * import { parseCallbackRequest } from 'vqs';
- *
- * // In your webhook handler
- * export async function POST(request: Request) {
- *   try {
- *     const callbackOptions = parseCallbackRequest(request);
- *
- *     // Use with receiveMessageById
- *     const message = await client.receiveMessageById({
- *       ...callbackOptions,
- *       visibilityTimeoutSeconds: 30
- *     }, transport);
+ * // Single topic with multiple consumer groups
+ * export const POST = handleCallback({
+ *   "image-processing": {
+ *     "compress": (message, metadata) => console.log("Compressing image", message),
+ *     "resize": (message, metadata) => console.log("Resizing image", message),
+ *   }
+ * });
  *
- *     // Process the message...
- *   } catch (error) {
- *     if (error instanceof InvalidCallbackError) {
- *       return new Response('Invalid callback', { status: 400 });
- *     }
- *     throw error;
+ * // Multiple topics with consumer groups
+ * export const POST = handleCallback({
+ *   "user-events": {
+ *     "welcome": (user, metadata) => console.log("Welcoming user", user),
+ *     "analytics": (user, metadata) => console.log("Tracking user", user),
+ *   },
+ *   "order-events": {
+ *     "fulfillment": (order, metadata) => console.log("Fulfilling order", order),
+ *     "notifications": (order, metadata) => console.log("Notifying order", order),
  *   }
- * }
+ * });
  * ```
  */
-declare function parseCallbackRequest(request: Request): CallbackMessageOptions;
-
-declare function getVercelOidcToken(): Promise<string>;
+declare function handleCallback(handlers: CallbackHandlers): (request: Request) => Promise<Response>;
 
-export { BadRequestError, BufferTransport, type CallbackConfig, type CallbackMessageOptions, type ChangeVisibilityOptions, type ChangeVisibilityResponse, ConsumerGroup, type ConsumerGroupOptions, type DeleteMessageOptions, type DeleteMessageResponse, FailedDependencyError, type FifoOrderingError, FifoOrderingViolationError, ForbiddenError, InternalServerError, InvalidCallbackError, InvalidLimitError, JsonTransport, type Message, MessageCorruptedError, type MessageHandler, type MessageHandlerResult, MessageLockedError, MessageNotAvailableError, MessageNotFoundError, type MessageTimeoutResult, QueueEmptyError, type ReceiveMessageByIdOptions, type ReceiveMessageByIdResponse, type ReceiveMessagesOptions, type SendMessageOptions, type SendMessageResponse, StreamTransport, Topic, type Transport, UnauthorizedError, VQSClient, type VQSClientOptions, createTopic, getVercelOidcToken, parseCallbackRequest };
+export { BadRequestError, BufferTransport, ForbiddenError, InternalServerError, InvalidLimitError, JsonTransport, type Message, MessageCorruptedError, type MessageHandler, type MessageHandlerResult, MessageLockedError, type MessageMetadata, MessageNotAvailableError, MessageNotFoundError, type MessageTimeoutResult, type PublishOptions, QueueEmptyError, type ReceiveOptions, type SendMessageOptions, type SendMessageResponse, type SendOptions, StreamTransport, type Transport, UnauthorizedError, handleCallback, receive, send };