@vercel/queue 0.0.0-alpha.1

package/dist/index.d.mts

@@ -0,0 +1,725 @@
+/**
+ * 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 VQSClient 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>;
+}
+
+/**
+ * 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
+ */
+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;
+    /**
+     * Consumer group callback configurations
+     * Format: { consumerGroup: { url, delay?, frequency? } }
+     */
+    callbacks?: Record<string, 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
+ */
+interface MessageTimeoutResult {
+    /**
+     * Time in seconds before the message becomes visible again
+     */
+    timeoutSeconds: number;
+}
+/**
+ * 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
+ */
+interface ConsumerGroupOptions<T = unknown> {
+    /**
+     * 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)
+ */
+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);
+}
+/**
+ * Error thrown for bad requests (400)
+ */
+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)
+ */
+declare class InternalServerError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Error thrown when batch limit parameter is invalid
+ */
+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
+ */
+declare class InvalidCallbackError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * Client for interacting with the Vercel Queue Service API
+ */
+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>>;
+    /**
+     * 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 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;
+}
+
+/**
+ * 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 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>;
+}
+
+/**
+ * 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
+ */
+declare function createTopic<T = unknown>(client: VQSClient, topicName: string, transport?: Transport<T>): Topic<T>;
+
+/**
+ * VQS Callback utilities for handling incoming webhook payloads
+ */
+
+/**
+ * Parse a VQS callback request and extract the required information for receiveMessageById
+ *
+ * @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
+ *
+ * @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);
+ *
+ *     // Process the message...
+ *   } catch (error) {
+ *     if (error instanceof InvalidCallbackError) {
+ *       return new Response('Invalid callback', { status: 400 });
+ *     }
+ *     throw error;
+ *   }
+ * }
+ * ```
+ */
+declare function parseCallbackRequest(request: Request): CallbackMessageOptions;
+
+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, 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 };