@vercel/queue 0.0.0-alpha.39 → 0.0.0-alpha.40

package/dist/callback-lq_sorrn.d.ts

@@ -1,718 +0,0 @@
-/**
- * Serializer/Deserializer interface for message payloads.
- *
- * Built-in implementations:
- * - `JsonTransport` - JSON serialization (default, buffers entire payload)
- * - `BufferTransport` - Binary data (buffers entire payload)
- * - `StreamTransport` - Pass-through streaming (no buffering, ideal for large payloads)
- */
-interface Transport<T = unknown> {
-    /**
-     * Serialize a value to a buffer or stream for transmission.
-     * The result is sent as the request body with the `contentType` header.
-     */
-    serialize(value: T): Buffer | ReadableStream<Uint8Array>;
-    /**
-     * Deserialize a readable stream back to the original value.
-     * Called when receiving messages from the queue.
-     */
-    deserialize(stream: ReadableStream<Uint8Array>): Promise<T>;
-    /**
-     * Optional cleanup method for deserialized payloads that may contain resources.
-     * Called automatically by ConsumerGroup on error; manual cleanup required for direct client usage.
-     * @param payload The deserialized payload to clean up
-     */
-    finalize?(payload: T): Promise<void>;
-    /**
-     * MIME type for this serialization format.
-     * Sent as the Content-Type header when publishing messages.
-     */
-    contentType: string;
-}
-/**
- * JSON serializer/deserializer (default transport).
- *
- * Ideal for structured data. Buffers the entire payload in memory for parsing.
- *
- * @example
- * ```typescript
- * // Default usage
- * await send("topic", { data: "example" });
- *
- * // With custom serialization
- * const transport = new JsonTransport({
- *   replacer: (key, value) => key === "password" ? undefined : value,
- *   reviver: (key, value) => key === "date" ? new Date(value) : value,
- * });
- * await send("topic", { data: "example" }, { transport });
- * ```
- */
-declare class JsonTransport<T = unknown> implements Transport<T> {
-    readonly contentType = "application/json";
-    readonly replacer?: Parameters<typeof JSON.stringify>[1];
-    readonly reviver?: Parameters<typeof JSON.parse>[1];
-    /**
-     * Create a new JsonTransport.
-     * @param options - Optional JSON serialization options
-     * @param options.replacer - Custom replacer for JSON.stringify
-     * @param options.reviver - Custom reviver for JSON.parse
-     */
-    constructor(options?: {
-        replacer?: Parameters<typeof JSON.stringify>[1];
-        reviver?: Parameters<typeof JSON.parse>[1];
-    });
-    serialize(value: T): Buffer;
-    deserialize(stream: ReadableStream<Uint8Array>): Promise<T>;
-}
-/**
- * Binary data serializer/deserializer.
- *
- * Ideal for binary data that fits in memory. Buffers the entire payload.
- *
- * @example
- * ```typescript
- * const transport = new BufferTransport();
- * await send("binary-topic", myBuffer, { transport });
- * ```
- */
-declare class BufferTransport implements Transport<Buffer> {
-    readonly contentType = "application/octet-stream";
-    serialize(value: Buffer): Buffer;
-    deserialize(stream: ReadableStream<Uint8Array>): Promise<Buffer>;
-}
-/**
- * Pass-through stream serializer/deserializer.
- *
- * Ideal for large files and real-time streams. Does not buffer data in memory.
- *
- * **Important:** When using StreamTransport, you must call `finalize(payload)` when done
- * processing to prevent resource leaks. ConsumerGroup handles this automatically;
- * direct client usage requires manual cleanup.
- *
- * @example
- * ```typescript
- * const transport = new StreamTransport();
- *
- * // Sending a stream
- * await send("large-file", myReadableStream, { transport });
- *
- * // Receiving - cleanup handled by ConsumerGroup
- * await receive("large-file", "processor", async (stream, meta) => {
- *   const reader = stream.getReader();
- *   // Process chunks...
- * }, { transport });
- *
- * // Direct client usage - manual cleanup required
- * try {
- *   for await (const msg of client.receiveMessages(options, transport)) {
- *     // Process stream...
- *   }
- * } catch (error) {
- *   await transport.finalize(msg.payload); // Manual cleanup
- * }
- * ```
- */
-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>>;
-    /**
-     * Consume any remaining stream data to prevent resource leaks.
-     * Called automatically by ConsumerGroup; manual call required for direct client usage.
-     */
-    finalize(payload: ReadableStream<Uint8Array>): Promise<void>;
-}
-
-/**
- * Vercel Queue Service client types
- */
-
-interface QueueClientOptions {
-    /**
-     * Base URL for the Vercel Queue Service API.
-     * Can also be set via VERCEL_QUEUE_BASE_URL environment variable.
-     * @default "https://vercel-queue.com"
-     */
-    baseUrl?: string;
-    /**
-     * Base path for API endpoints.
-     * Can also be set via VERCEL_QUEUE_BASE_PATH environment variable.
-     * @default "/api/v3/topic"
-     */
-    basePath?: string;
-    /**
-     * Authentication token for the Vercel Queue Service API.
-     * If not provided, the client will attempt to get a token via OIDC
-     * when running in a Vercel Function environment.
-     */
-    token?: string;
-    /**
-     * Custom headers to include in all requests.
-     */
-    headers?: Record<string, string>;
-    /**
-     * Deployment ID to include in requests.
-     * Used for message routing and lease validation.
-     * @default process.env.VERCEL_DEPLOYMENT_ID if pinToDeployment is true
-     */
-    deploymentId?: string;
-    /**
-     * Whether to pin messages to the current deployment when publishing.
-     * When true, sends VERCEL_DEPLOYMENT_ID from environment, ensuring
-     * messages are routed to consumers on the same deployment.
-     *
-     * - Only affects send/publish operations
-     * - Consume operations always send deployment ID in production
-     * - Ignored in development mode (deployment ID is never sent locally)
-     * @default true
-     */
-    pinToDeployment?: boolean;
-    /**
-     * Serializer/deserializer for message payloads.
-     * Used for all send and receive operations.
-     * @default JsonTransport
-     */
-    transport?: Transport;
-}
-/**
- * Options for publishing messages to a topic.
- */
-interface PublishOptions {
-    /**
-     * Unique key to prevent duplicate message submissions.
-     * Deduplication window: `min(message retention, 24 hours)`.
-     */
-    idempotencyKey?: string;
-    /**
-     * Message retention time in seconds. After this period, the message expires.
-     * @default 86400 (24 hours)
-     * @minimum 60 (1 minute)
-     * @maximum 86400 (24 hours)
-     */
-    retentionSeconds?: number;
-    /**
-     * Delay delivery of the message by this many seconds.
-     * The message will not be visible to consumers until the delay has passed.
-     * @default 0
-     * @minimum 0
-     * @maximum Value of retentionSeconds (delay cannot exceed retention)
-     */
-    delaySeconds?: number;
-    /**
-     * Custom headers to include with this message.
-     * These headers are passed through to the VQS server.
-     */
-    headers?: Record<string, string>;
-}
-interface SendMessageOptions<T = unknown> extends PublishOptions {
-    /**
-     * The topic/queue name to send the message to.
-     * Must match pattern: `[A-Za-z0-9_-]+`
-     */
-    queueName: string;
-    /**
-     * The message payload. Will be serialized using the provided transport.
-     */
-    payload: T;
-}
-interface SendMessageResponse {
-    /**
-     * The generated message ID
-     */
-    messageId: string;
-}
-interface Message<T = unknown> {
-    /**
-     * Unique message identifier. Used for receive-by-ID operations.
-     */
-    messageId: string;
-    /**
-     * The deserialized message payload.
-     * Note: If using StreamTransport, 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.
-     * Starts at 1 for the first delivery, increments on each retry.
-     */
-    deliveryCount: number;
-    /**
-     * Timestamp when the message was created/published.
-     */
-    createdAt: Date;
-    /**
-     * MIME type of the message content.
-     * Set by the transport's `contentType` property during publish.
-     */
-    contentType: string;
-    /**
-     * Receipt handle (lease token) for this message delivery.
-     * Required for delete and visibility extension operations.
-     * Valid only until the visibility timeout expires.
-     */
-    receiptHandle: string;
-}
-interface ReceiveMessagesOptions<T = unknown> {
-    /**
-     * The topic/queue name to receive messages from.
-     * Must match pattern: `[A-Za-z0-9_-]+`
-     */
-    queueName: string;
-    /**
-     * Consumer group name. Each consumer group maintains independent message state.
-     * Must match pattern: `[A-Za-z0-9_-]+`
-     */
-    consumerGroup: string;
-    /**
-     * Time in seconds that messages will be invisible to other consumers after receipt.
-     * Set to 0 for immediate re-visibility (useful for peeking).
-     * @default 30
-     * @minimum 0
-     * @maximum 3600 (1 hour)
-     */
-    visibilityTimeoutSeconds?: number;
-    /**
-     * Maximum number of messages to retrieve in a single request.
-     * @default 1
-     * @minimum 1
-     * @maximum 10
-     */
-    limit?: number;
-}
-interface DeleteMessageOptions {
-    /**
-     * The topic/queue name the message belongs to.
-     */
-    queueName: string;
-    /**
-     * Consumer group name.
-     */
-    consumerGroup: string;
-    /**
-     * Receipt handle received when the message was consumed.
-     */
-    receiptHandle: string;
-}
-interface DeleteMessageResponse {
-    /**
-     * Whether the message was successfully deleted
-     */
-    deleted: boolean;
-}
-interface ChangeVisibilityOptions {
-    /**
-     * The topic/queue name the message belongs to.
-     */
-    queueName: string;
-    /**
-     * Consumer group name.
-     */
-    consumerGroup: string;
-    /**
-     * Receipt handle received when the message was consumed.
-     */
-    receiptHandle: string;
-    /**
-     * New visibility timeout in seconds.
-     * Cannot extend beyond the message's original expiration time.
-     * @minimum 0
-     * @maximum 3600 (1 hour)
-     */
-    visibilityTimeoutSeconds: number;
-}
-interface ChangeVisibilityResponse {
-    /**
-     * Whether the visibility was successfully updated
-     */
-    success: boolean;
-}
-/**
- * Message metadata provided to handlers
- */
-interface MessageMetadata {
-    messageId: string;
-    deliveryCount: number;
-    createdAt: Date;
-    topicName: string;
-    consumerGroup: string;
-}
-/**
- * Message handler function type
- *
- * When a message is available, both `message` and `metadata` are provided.
- * When the queue is empty, both `message` and `metadata` are `null`.
- * This allows handlers to gracefully handle the empty queue case without
- * catching exceptions.
- */
-type MessageHandler<T = unknown> = (message: T | null, metadata: MessageMetadata | null) => Promise<void> | void;
-/**
- * Options for creating a ConsumerGroup instance.
- */
-interface ConsumerGroupOptions<T = unknown> {
-    /**
-     * Time in seconds that messages will be invisible to other consumers after receipt.
-     * The ConsumerGroup will automatically extend this timeout during processing.
-     * @default 300 (5 minutes)
-     * @minimum 30
-     * @maximum 3600 (1 hour)
-     */
-    visibilityTimeoutSeconds?: number;
-}
-interface ReceiveMessageByIdOptions<T = unknown> {
-    /**
-     * The topic/queue name to receive the message from.
-     * Must match pattern: `[A-Za-z0-9_-]+`
-     */
-    queueName: string;
-    /**
-     * Consumer group name.
-     * Must match pattern: `[A-Za-z0-9_-]+`
-     */
-    consumerGroup: string;
-    /**
-     * The specific message ID to retrieve.
-     */
-    messageId: string;
-    /**
-     * Time in seconds that the message will be invisible to other consumers after receipt.
-     * @default 30
-     * @minimum 0
-     * @maximum 3600 (1 hour)
-     */
-    visibilityTimeoutSeconds?: number;
-}
-interface ReceiveMessageByIdResponse<T = unknown> {
-    message: Message<T>;
-}
-/**
- * Error thrown when a message does not exist or has expired.
- */
-declare class MessageNotFoundError extends Error {
-    constructor(messageId: string);
-}
-/**
- * Error thrown when a message exists but cannot be processed.
- * This can happen when the message is in the wrong state or already claimed by another consumer.
- */
-declare class MessageNotAvailableError extends Error {
-    constructor(messageId: 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.
- */
-declare class QueueEmptyError extends Error {
-    constructor(queueName: string, consumerGroup: string);
-}
-/**
- * Error thrown when a message is temporarily locked by another consumer.
- * The message is currently being processed and cannot be claimed.
- */
-declare class MessageLockedError extends Error {
-    /** Suggested retry delay in seconds, if provided by the server. */
-    readonly retryAfter?: number;
-    constructor(messageId: string, retryAfter?: number);
-}
-/**
- * Error thrown when authentication fails.
- * This typically means the token is missing, invalid, or expired.
- */
-declare class UnauthorizedError extends Error {
-    constructor(message?: string);
-}
-/**
- * Error thrown when access is forbidden.
- * This typically means the queue belongs to a different environment or project.
- */
-declare class ForbiddenError extends Error {
-    constructor(message?: string);
-}
-/**
- * Error thrown when request parameters are invalid.
- */
-declare class BadRequestError extends Error {
-    constructor(message: string);
-}
-/**
- * Error thrown when the server encounters an unexpected error.
- */
-declare class InternalServerError extends Error {
-    constructor(message?: string);
-}
-/**
- * Error thrown when the batch limit parameter is outside the valid range.
- * The limit must be between 1 and 10 (inclusive).
- */
-declare class InvalidLimitError extends Error {
-    constructor(limit: number, min?: number, max?: number);
-}
-/**
- * Error thrown when attempting to process a message that has already been successfully processed.
- */
-declare class MessageAlreadyProcessedError extends Error {
-    constructor(messageId: string);
-}
-/**
- * Error thrown when a duplicate idempotency key is detected.
- * The message was already sent within the deduplication window.
- */
-declare class DuplicateMessageError extends Error {
-    readonly idempotencyKey?: string;
-    constructor(message: string, idempotencyKey?: string);
-}
-/**
- * Error thrown when consumer discovery fails.
- * This typically means the deployment could not be reached or is not configured correctly.
- */
-declare class ConsumerDiscoveryError extends Error {
-    readonly deploymentId?: string;
-    constructor(message: string, deploymentId?: string);
-}
-/**
- * Error thrown when the consumer registry is not configured for the project.
- */
-declare class ConsumerRegistryNotConfiguredError extends Error {
-    constructor(message?: string);
-}
-
-declare class QueueClient {
-    private baseUrl;
-    private basePath;
-    private customHeaders;
-    private providedToken?;
-    private defaultDeploymentId?;
-    private pinToDeployment;
-    private transport;
-    constructor(options?: QueueClientOptions);
-    getTransport(): Transport;
-    private getSendDeploymentId;
-    private getConsumeDeploymentId;
-    private getToken;
-    private buildUrl;
-    private fetch;
-    /**
-     * Send a message to a topic.
-     *
-     * @param options - Message options including queue name, payload, and optional settings
-     * @param options.queueName - Topic name (pattern: `[A-Za-z0-9_-]+`)
-     * @param options.payload - Message payload
-     * @param options.idempotencyKey - Optional deduplication key (dedup window: min(retention, 24h))
-     * @param options.retentionSeconds - Message TTL (default: 86400, min: 60, max: 86400)
-     * @param options.delaySeconds - Delivery delay (default: 0, max: retentionSeconds)
-     * @returns Promise with the generated messageId
-     * @throws {DuplicateMessageError} When idempotency key was already used
-     * @throws {ConsumerDiscoveryError} When consumer discovery fails
-     * @throws {ConsumerRegistryNotConfiguredError} When registry not configured
-     * @throws {BadRequestError} When parameters are invalid
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied
-     * @throws {InternalServerError} When server encounters an error
-     */
-    sendMessage<T = unknown>(options: SendMessageOptions<T>): Promise<SendMessageResponse>;
-    /**
-     * Receive messages from a topic as an async generator.
-     *
-     * When the queue is empty, the generator completes without yielding any
-     * messages. Callers should handle the case where no messages are yielded.
-     *
-     * @param options - Receive options
-     * @param options.queueName - Topic name (pattern: `[A-Za-z0-9_-]+`)
-     * @param options.consumerGroup - Consumer group name (pattern: `[A-Za-z0-9_-]+`)
-     * @param options.visibilityTimeoutSeconds - Lock duration (default: 30, min: 0, max: 3600)
-     * @param options.limit - Max messages to retrieve (default: 1, min: 1, max: 10)
-     * @yields Message objects with payload, messageId, receiptHandle, etc.
-     *         Yields nothing if queue is empty.
-     * @throws {InvalidLimitError} When limit is outside 1-10 range
-     * @throws {BadRequestError} When parameters are invalid
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied
-     * @throws {InternalServerError} When server encounters an error
-     */
-    receiveMessages<T = unknown>(options: ReceiveMessagesOptions<T>): AsyncGenerator<Message<T>, void, unknown>;
-    /**
-     * Receive a specific message by its ID.
-     *
-     * @param options - Receive options
-     * @param options.queueName - Topic name (pattern: `[A-Za-z0-9_-]+`)
-     * @param options.consumerGroup - Consumer group name (pattern: `[A-Za-z0-9_-]+`)
-     * @param options.messageId - Message ID to retrieve
-     * @param options.visibilityTimeoutSeconds - Lock duration (default: 30, min: 0, max: 3600)
-     * @returns Promise with the message
-     * @throws {MessageNotFoundError} When message doesn't exist
-     * @throws {MessageNotAvailableError} When message is in wrong state or was a duplicate
-     * @throws {MessageAlreadyProcessedError} When message was already processed
-     * @throws {BadRequestError} When parameters are invalid
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied
-     * @throws {InternalServerError} When server encounters an error
-     */
-    receiveMessageById<T = unknown>(options: ReceiveMessageByIdOptions<T>): Promise<ReceiveMessageByIdResponse<T>>;
-    /**
-     * Delete (acknowledge) a message after successful processing.
-     *
-     * @param options - Delete options
-     * @param options.queueName - Topic name
-     * @param options.consumerGroup - Consumer group name
-     * @param options.receiptHandle - Receipt handle from the received message (must use same deployment ID as receive)
-     * @returns Promise indicating deletion success
-     * @throws {MessageNotFoundError} When receipt handle not found
-     * @throws {MessageNotAvailableError} When receipt handle invalid or message already processed
-     * @throws {BadRequestError} When parameters are invalid
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied
-     * @throws {InternalServerError} When server encounters an error
-     */
-    deleteMessage(options: DeleteMessageOptions): Promise<DeleteMessageResponse>;
-    /**
-     * Extend or change the visibility timeout of a message.
-     * Used to prevent message redelivery while still processing.
-     *
-     * @param options - Visibility options
-     * @param options.queueName - Topic name
-     * @param options.consumerGroup - Consumer group name
-     * @param options.receiptHandle - Receipt handle from the received message (must use same deployment ID as receive)
-     * @param options.visibilityTimeoutSeconds - New timeout (min: 0, max: 3600, cannot exceed message expiration)
-     * @returns Promise indicating success
-     * @throws {MessageNotFoundError} When receipt handle not found
-     * @throws {MessageNotAvailableError} When receipt handle invalid or message already processed
-     * @throws {BadRequestError} When parameters are invalid
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied
-     * @throws {InternalServerError} When server encounters an error
-     */
-    changeVisibility(options: ChangeVisibilityOptions): Promise<ChangeVisibilityResponse>;
-    /**
-     * Alternative endpoint for changing message visibility timeout.
-     * Uses the /visibility path suffix and expects visibilityTimeoutSeconds in the body.
-     * Functionally equivalent to changeVisibility but follows an alternative API pattern.
-     *
-     * @param options - Options for changing visibility
-     * @returns Promise resolving to change visibility response
-     */
-    changeVisibilityAlt(options: ChangeVisibilityOptions): Promise<ChangeVisibilityResponse>;
-}
-
-/**
- * Core queue callback utilities for handling incoming webhook payloads
- * from Vercel triggers using the CloudEvent specification.
- *
- * This module provides the framework-agnostic core. For framework-specific
- * wrappers, see `@vercel/queue/web` and `@vercel/queue/nextjs/pages`.
- */
-
-/**
- * Options for configuring `handleCallback` behavior.
- */
-interface HandleCallbackOptions {
-    /**
-     * QueueClient instance to use for processing messages.
-     * If not provided, a default client is created with OIDC authentication
-     * and JsonTransport.
-     */
-    client?: QueueClient;
-    /**
-     * Time in seconds that messages will be invisible to other consumers
-     * during processing. The handler will automatically extend this timeout
-     * while processing.
-     *
-     * @default 300 (5 minutes)
-     * @minimum 30
-     * @maximum 3600 (1 hour)
-     */
-    visibilityTimeoutSeconds?: number;
-}
-declare const CLOUD_EVENT_TYPE_V1BETA = "com.vercel.queue.v1beta";
-declare const CLOUD_EVENT_TYPE_V2BETA = "com.vercel.queue.v2beta";
-/**
- * Routing-only callback: the SDK must fetch the message by ID.
- * Produced by v1beta structured mode and v2beta large-body mode.
- */
-type ParsedCallbackV1 = {
-    queueName: string;
-    consumerGroup: string;
-    messageId: string;
-};
-/**
- * Full-message callback: payload and receipt handle are inlined,
- * so the SDK can process directly without an extra fetch.
- * Produced by v2beta small-body mode.
- */
-type ParsedCallbackV2 = {
-    queueName: string;
-    consumerGroup: string;
-    messageId: string;
-    receiptHandle: string;
-    deliveryCount?: number;
-    createdAt?: string;
-    contentType?: string;
-    visibilityDeadline?: string;
-    rawBody?: ReadableStream<Uint8Array>;
-    parsedPayload?: unknown;
-};
-type ParsedCallbackRequest = ParsedCallbackV1 | ParsedCallbackV2;
-/**
- * Parse a callback from a pre-parsed body and headers.
- *
- * For frameworks like Next.js Pages Router where the body has already been
- * parsed, use this instead of {@link parseCallback}.
- *
- * Detects the CloudEvent version from the `ce-type` header:
- * - `com.vercel.queue.v2beta`: binary content mode (metadata in headers,
- *   payload in body). For small messages, the body is attached as `parsedPayload`.
- * - Otherwise: structured content mode (v1beta, entire CloudEvent in JSON body)
- *
- * @param body - The framework-parsed request body. Type depends on Content-Type
- *   and framework configuration:
- *   - v1beta: parsed CloudEvent JSON object
- *   - v2beta: the message payload as parsed by the framework (object, Buffer, or string)
- * @param headers - HTTP headers
- * @returns Parsed callback request with routing metadata and optional payload
- */
-declare function parseRawCallback(body: unknown, headers: Record<string, string | string[] | undefined>): ParsedCallbackRequest;
-/**
- * Parse and validate a CloudEvent callback from a Web API `Request` object.
- *
- * Detects the CloudEvent version from the `ce-type` header:
- * - `com.vercel.queue.v2beta`: binary content mode (metadata in headers,
- *   payload in body). For v2beta, the body is attached as `rawBody` (a
- *   ReadableStream) rather than being parsed.
- * - Otherwise: structured content mode (v1beta, entire CloudEvent in JSON body)
- *
- * For frameworks that pre-parse the body (e.g. Next.js Pages Router),
- * use {@link parseRawCallback} instead.
- */
-declare function parseCallback(request: Request): Promise<ParsedCallbackRequest>;
-/**
- * Core queue callback handler. Processes the message using the provided handler.
- *
- * This is the framework-agnostic core — it takes already-parsed request data
- * and throws on errors. Framework-specific wrappers (in `@vercel/queue/web`
- * and `@vercel/queue/nextjs/pages`) compose around this function to handle
- * request parsing and response formatting.
- *
- * @param handler - Function to process the message payload and metadata
- * @param request - A {@link ParsedCallbackV1} (routing metadata only, message
- *   fetched by ID) or {@link ParsedCallbackV2} (full message inlined, no fetch).
- * @param options - Optional configuration (client, visibilityTimeoutSeconds)
- * @throws {Error} If binary mode request has a receipt handle but no payload
- * @throws {Error} If message processing fails
- *
- * @example
- * ```typescript
- * import { handleCallback, parseRawCallback } from "@vercel/queue";
- *
- * const parsed = parseRawCallback(body, headers);
- * await handleCallback(async (message, metadata) => {
- *   console.log("Processing:", message);
- * }, parsed);
- * ```
- */
-declare function handleCallback<T = unknown>(handler: MessageHandler<T>, request: ParsedCallbackRequest, options?: HandleCallbackOptions): Promise<void>;
-
-export { BufferTransport as B, type ConsumerGroupOptions as C, DuplicateMessageError as D, ForbiddenError as F, type HandleCallbackOptions as H, InternalServerError as I, JsonTransport as J, type MessageHandler as M, type PublishOptions as P, QueueClient as Q, StreamTransport as S, type Transport as T, UnauthorizedError as U, CLOUD_EVENT_TYPE_V1BETA as a, CLOUD_EVENT_TYPE_V2BETA as b, parseRawCallback as c, type ParsedCallbackRequest as d, type ParsedCallbackV1 as e, type ParsedCallbackV2 as f, BadRequestError as g, handleCallback as h, ConsumerDiscoveryError as i, ConsumerRegistryNotConfiguredError as j, InvalidLimitError as k, MessageAlreadyProcessedError as l, MessageCorruptedError as m, MessageLockedError as n, MessageNotAvailableError as o, parseCallback as p, MessageNotFoundError as q, QueueEmptyError as r, type Message as s, type MessageMetadata as t, type QueueClientOptions as u, type SendMessageOptions as v, type SendMessageResponse as w };