@vercel/queue 0.0.0-alpha.3 → 0.0.0-alpha.30

package/dist/index.d.ts

@@ -1,775 +1,159 @@
-/**
- * Serializer/Deserializer interface for message payloads
- */
-interface Transport<T = unknown> {
-    /**
-     * Serialize a value to a buffer or stream for transmission
-     */
-    serialize(value: T): Buffer | ReadableStream<Uint8Array>;
-    /**
-     * Deserialize a readable stream back to the original value
-     */
-    deserialize(stream: ReadableStream<Uint8Array>): Promise<T>;
-    /**
-     * Optional cleanup method for deserialized payloads that may contain resources
-     * Should be called when the payload is no longer needed, especially in error cases
-     * @param payload The deserialized payload to clean up
-     */
-    finalize?(payload: T): Promise<void>;
-    /**
-     * MIME type for this serialization format
-     */
-    contentType: string;
-}
-/**
- * Built-in JSON serializer/deserializer
- * This implementation reads the entire stream into memory for JSON parsing
- */
-declare class JsonTransport<T = unknown> implements Transport<T> {
-    readonly contentType = "application/json";
-    serialize(value: T): Buffer;
-    deserialize(stream: ReadableStream<Uint8Array>): Promise<T>;
-}
-/**
- * Built-in Buffer serializer/deserializer (reads entire stream into a Buffer)
- */
-declare class BufferTransport implements Transport<Buffer> {
-    readonly contentType = "application/octet-stream";
-    serialize(value: Buffer): Buffer;
-    deserialize(stream: ReadableStream<Uint8Array>): Promise<Buffer>;
-}
-/**
- * Stream serializer/deserializer (pass-through for streaming binary data)
- * This is ideal for large payloads that don't need to be buffered in memory
- *
- * 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 QueueClient usage requires manual cleanup.
- *
- * Example usage:
- * ```typescript
- * const transport = new StreamTransport();
- * try {
- *   for await (const message of client.receiveMessages(options, transport)) {
- *     // Process the stream...
- *     const reader = message.payload.getReader();
- *     // ... handle stream data
- *   }
- * } catch (error) {
- *   // Cleanup is handled automatically by ConsumerGroup
- *   // or manually: await transport.finalize(message.payload);
- * }
- */
-declare class StreamTransport implements Transport<ReadableStream<Uint8Array>> {
-    readonly contentType = "application/octet-stream";
-    serialize(value: ReadableStream<Uint8Array>): ReadableStream<Uint8Array>;
-    deserialize(stream: ReadableStream<Uint8Array>): Promise<ReadableStream<Uint8Array>>;
-    finalize(payload: ReadableStream<Uint8Array>): Promise<void>;
-}
+import { M as MessageHandler, C as ConsumerGroupOptions, P as PublishOptions, T as Transport } from './types-JvOenjfT.js';
+export { a as BadRequestError, B as BufferTransport, F as ForbiddenError, I as InternalServerError, b as InvalidLimitError, J as JsonTransport, g as Message, c as MessageCorruptedError, h as MessageHandlerResult, d as MessageLockedError, i as MessageMetadata, e as MessageNotAvailableError, f as MessageNotFoundError, j as MessageTimeoutResult, Q as QueueEmptyError, k as SendMessageOptions, l as SendMessageResponse, S as StreamTransport, U as UnauthorizedError } from './types-JvOenjfT.js';
 
 /**
- * Vercel Queue Service client types
- */
-
-interface QueueClientOptions {
-    /**
-     * 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
- */
-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;
-    /**
-     * Unique key to prevent duplicate message submissions
-     * @default random UUID
-     */
-    idempotencyKey?: string;
-    /**
-     * Message retention time in seconds
-     * @default 86400 (24 hours)
-     * @min 60
-     * @max 86400
-     */
-    retentionSeconds?: number;
-    /**
-     * Callback configuration
-     * - If a single CallbackConfig is provided, it will use the "default" consumer group
-     * - If an object is provided, keys are consumer group names with their respective callback configs
-     * Format: { consumerGroup: { url, delay?, frequency? } } or { url, delay?, frequency? }
-     */
-    callback?: Record<string, CallbackConfig> | CallbackConfig;
-}
-interface SendMessageResponse {
-    /**
-     * The generated message ID
-     */
-    messageId: string;
-}
-interface Message<T = unknown> {
-    /**
-     * The message ID
-     */
-    messageId: string;
-    /**
-     * The deserialized message payload
-     * Note: If using streaming transports, ensure proper cleanup by calling transport.finalize(payload)
-     * when done processing, especially in error cases
-     */
-    payload: T;
-    /**
-     * Number of times this message has been delivered
-     */
-    deliveryCount: number;
-    /**
-     * Timestamp when the message was created
-     */
-    timestamp: string;
-    /**
-     * MIME type of the message content
-     */
-    contentType: string;
-    /**
-     * Unique ticket for this message delivery (required for delete/patch operations)
-     */
-    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
+ * Options for the consume method
  */
-interface MessageTimeoutResult {
-    /**
-     * Time in seconds before the message becomes visible again
-     */
-    timeoutSeconds: number;
+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;
 }
+
 /**
- * Result returned by message handlers
- */
-type MessageHandlerResult = void | MessageTimeoutResult;
-/**
- * Message handler function type
- */
-type MessageHandler<T = unknown> = (message: Message<T>) => Promise<MessageHandlerResult> | MessageHandlerResult;
-/**
- * Options for creating a ConsumerGroup instance
+ * Options for the send function
  */
-interface ConsumerGroupOptions<T = unknown> {
+interface SendOptions<T = unknown> extends PublishOptions {
     /**
      * Serializer/deserializer for the payload
      * @default JsonTransport instance
      */
     transport?: Transport<T>;
-    /**
-     * Time in seconds that messages will be invisible to other consumers
-     * @default 30
-     */
-    visibilityTimeoutSeconds?: number;
-    /**
-     * How often to refresh the visibility timeout during processing (in seconds)
-     * @default 10
-     */
-    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)
+ * 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 MessageNotFoundError extends Error {
-    constructor(messageId: string);
-}
-/**
- * Error thrown when a message is not available for processing (409)
- * This can happen when the message is in the wrong state, already claimed, etc.
- */
-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
- */
-declare class MessageCorruptedError extends Error {
-    constructor(messageId: string, reason: string);
-}
-/**
- * Error thrown when there are no messages available in the queue (204)
- */
-declare class QueueEmptyError extends Error {
-    constructor(queueName: string, consumerGroup: string);
-}
-/**
- * Error thrown when a message is temporarily locked in a FIFO queue (423)
- */
-declare class MessageLockedError extends Error {
-    readonly retryAfter?: number;
-    constructor(messageId: string, retryAfter?: number);
-}
-/**
- * Error thrown when authentication fails (401)
- */
-declare class UnauthorizedError extends Error {
-    constructor(message?: string);
-}
-/**
- * Error thrown when access is forbidden (403)
- */
-declare class ForbiddenError extends Error {
-    constructor(message?: string);
-}
+declare function send<T = unknown>(topicName: string, payload: T, options?: SendOptions<T>): Promise<{
+    messageId: string;
+}>;
 /**
- * Error thrown for bad requests (400)
+ * Options for the receive function
  */
-declare class BadRequestError extends Error {
-    constructor(message: string);
+interface ReceiveOptions<T = unknown> extends ConsumerGroupOptions<T>, ConsumeOptions {
 }
 /**
- * Error thrown when there's a failed dependency (424) - FIFO ordering violation in receive by ID
+ * 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 class FailedDependencyError extends Error {
-    readonly nextMessageId: string;
-    constructor(messageId: string, nextMessageId: string);
-}
+declare function receive<T = unknown>(topicName: string, consumerGroup: string, handler: MessageHandler<T>, options?: ReceiveOptions<T>): Promise<void>;
 /**
- * Error thrown for internal server errors (500)
+ * 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 class InternalServerError extends Error {
-    constructor(message?: string);
-}
+declare function receive<T = unknown>(topicName: string, consumerGroup: string, handler: MessageHandler<T>, options: ReceiveOptions<T> & {
+    messageId: string;
+    skipPayload?: false | undefined;
+}): Promise<void>;
+/**
+ * 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>;
+
 /**
- * Error thrown when batch limit parameter is invalid
+ * Configuration object with handlers for different topics and consumer groups
  */
-declare class InvalidLimitError extends Error {
-    constructor(limit: number, min?: number, max?: number);
-}
+type CallbackHandlers = {
+    [topicName: string]: {
+        [consumerGroup: string]: MessageHandler;
+    };
+};
 /**
- * Options extracted from a queue callback request
+ * Parsed callback request information
  */
-interface CallbackMessageOptions {
-    /**
-     * The queue name extracted from Vqs-Queue-Name header
-     */
+type ParsedCallbackRequest = {
     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 queue callback headers are missing or invalid
- */
-declare class InvalidCallbackError extends Error {
-    constructor(message: string);
-}
-
-/**
- * Client for interacting with the Vercel Queue Service API
- */
-declare class QueueClient {
-    private baseUrl;
-    private token;
-    /**
-     * Create a new Vercel Queue Service client
-     * @param options Client configuration options
-     */
-    constructor(options: QueueClientOptions);
-    /**
-     * Create a QueueClient 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 QueueClient instance
-     */
-    static fromVercelFunction(baseUrl?: string): Promise<QueueClient>;
-    /**
-     * 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>>;
-    /**
-     * 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
-     */
-    changeVisibility(options: ChangeVisibilityOptions): Promise<ChangeVisibilityResponse>;
-}
-
-/**
- * A ConsumerGroup represents a named group of consumers that process messages from a topic
- */
-declare class ConsumerGroup<T = unknown> {
-    private client;
-    private topicName;
-    private consumerGroupName;
-    private visibilityTimeout;
-    private refreshInterval;
-    private transport;
-    /**
-     * Create a new ConsumerGroup instance
-     * @param client QueueClient 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: QueueClient, 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;
-}
-
-/**
- * A Topic represents a named channel for publishing messages in a pub/sub pattern
- */
-declare class Topic<T = unknown> {
-    private client;
-    private topicName;
-    private transport;
-    /**
-     * Create a new Topic instance
-     * @param client QueueClient 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: QueueClient, 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;
-        callback?: Record<string, CallbackConfig> | 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>;
-}
-
-/**
- * Create a new Topic instance
- * @param client QueueClient 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
- */
-declare function createTopic<T = unknown>(client: QueueClient, topicName: string, transport?: Transport<T>): Topic<T>;
-
-/**
- * Queue Callback utilities for handling incoming webhook payloads
- */
-
+};
 /**
- * Parse a queue callback request and extract the required information for receiveMessageById
+ * Parse and validate callback request using CloudEvent specification
  *
- * @param request The incoming Request object from the queue callback
- * @returns CallbackMessageOptions that can be used with receiveMessageById
- * @throws {InvalidCallbackError} When required queue headers are missing or invalid
+ * Extracts queue information from CloudEvent format and validates
+ * that all required fields are present.
+ *
+ * @param request The incoming webhook request
+ * @returns Parsed queue information
+ * @throws Error if required fields are missing
  *
  * @example
  * ```typescript
- * import { parseCallbackRequest } from '@vercel/queue';
- *
- * // In your webhook handler
+ * // In Next.js API route
  * export async function POST(request: Request) {
  *   try {
- *     const callbackOptions = parseCallbackRequest(request);
+ *     const { queueName, consumerGroup, messageId } = parseCallback(request);
  *
- *     // Use with receiveMessageById
- *     const message = await client.receiveMessageById({
- *       ...callbackOptions,
- *       visibilityTimeoutSeconds: 30
- *     }, transport);
+ *     // Use the parsed information...
+ *     await myWorkflow.handleWebhook(queueName, consumerGroup, messageId);
  *
- *     // Process the message...
+ *     return Response.json({ status: "success" });
  *   } catch (error) {
- *     if (error instanceof InvalidCallbackError) {
- *       return new Response('Invalid callback', { status: 400 });
- *     }
- *     throw error;
+ *     return Response.json({ error: error.message }, { status: 400 });
  *   }
  * }
  * ```
  */
-declare function parseCallbackRequest(request: Request): CallbackMessageOptions;
-/**
- * Message metadata provided to handlers
- */
-interface MessageMetadata {
-    messageId: string;
-    deliveryCount: number;
-    timestamp: string;
-}
-/**
- * Handler function signature
- */
-type Handler<T = unknown> = (payload: T, metadata: MessageMetadata) => Promise<MessageHandlerResult> | MessageHandlerResult;
-/**
- * Configuration object with handlers for different topics
- * Each topic can have either:
- * - A single handler function (uses 'default' consumer group)
- * - An object with handlers for specific consumer groups
- */
-type CallbackHandlers = {
-    [topicName: string]: Handler | {
-        [consumerGroup: string]: Handler;
-    };
-};
+declare function parseCallback(request: Request): Promise<ParsedCallbackRequest>;
 /**
- * Simplified queue callback handler for NextJS route handlers
+ * Simplified queue callback handler for Next.js route handlers
  *
- * @param handlers Object with topic-specific handlers
- * @returns A NextJS route handler function
+ * Automatically extracts queue information from CloudEvent format
+ * and routes to the appropriate handler based on topic and consumer group.
+ *
+ * @param handlers Object with topic-specific handlers organized by consumer groups
+ * @returns A Next.js route handler function
  *
  * @example
  * ```typescript
- * // Topic handler (uses 'default' consumer group)
+ * // Single topic with multiple consumer groups
  * export const POST = handleCallback({
- *   "new-users": (message, metadata) => {
- *     console.log(`New user event:`, message, metadata);
+ *   "image-processing": {
+ *     "compress": (message, metadata) => console.log("Compressing image", message),
+ *     "resize": (message, metadata) => console.log("Resizing image", message),
  *   }
  * });
  *
- * // Consumer group specific handlers
+ * // Multiple topics with consumer groups
  * export const POST = handleCallback({
- *   "image-processing": {
- *     "compress": (message, metadata) => console.log("Compressing image", message),
- *     "resize": (message, metadata) => console.log("Resizing image", message),
+ *   "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 handleCallback(handlers: CallbackHandlers): (request: Request) => Promise<Response>;
 
-declare function getVercelOidcToken(): Promise<string>;
-
-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, type MessageMetadata, MessageNotAvailableError, MessageNotFoundError, type MessageTimeoutResult, QueueClient, type QueueClientOptions, QueueEmptyError, type ReceiveMessageByIdOptions, type ReceiveMessageByIdResponse, type ReceiveMessagesOptions, type SendMessageOptions, type SendMessageResponse, StreamTransport, Topic, type Transport, UnauthorizedError, createTopic, getVercelOidcToken, handleCallback, parseCallbackRequest };
+export { MessageHandler, type ParsedCallbackRequest, PublishOptions, type ReceiveOptions, type SendOptions, Transport, handleCallback, parseCallback, receive, send };