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

package/README.md

@@ -1,12 +1,17 @@
 # Vercel Queues
 
-A TypeScript client library for interacting with the Vercel Queue Service API with customizable serialization/deserialization (transport) support, including **streaming support** for memory-efficient processing of large payloads.
+A TypeScript client library for interacting with the Vercel Queue Service API
+with customizable serialization/deserialization (transport) support, including
+**streaming support** for memory-efficient processing of large payloads.
 
 ## Features
 
-- **Generic Payload Support**: Send and receive any type of data with type safety
-- **Customizable Serialization**: Use built-in transports (JSON, Buffer, Stream) or create your own
-- **Streaming Support**: Handle large payloads without loading them entirely into memory
+- **Generic Payload Support**: Send and receive any type of data with type
+  safety
+- **Customizable Serialization**: Use built-in transports (JSON, Buffer, Stream)
+  or create your own
+- **Streaming Support**: Handle large payloads without loading them entirely
+  into memory
 - **Pub/Sub Pattern**: Topic-based messaging with consumer groups
 - **Type Safety**: Full TypeScript support with generic types
 - **Automatic Retries**: Built-in visibility timeout management
@@ -19,7 +24,8 @@ npm install @vercel/queue
 
 ## Quick Start
 
-For local development, you'll need to pull your Vercel environment variables (including the OIDC token):
+For local development, you'll need to pull your Vercel environment variables
+(including the OIDC token):
 
 ```bash
 # Install Vercel CLI if you haven't already
@@ -33,10 +39,10 @@ Publishing and consuming messages on a queue
 
 ```typescript
 // index.ts
-import { QueueClient, createTopic, JsonTransport } from "@vercel/queue";
+import { createTopic, JsonTransport, QueueClient } from "@vercel/queue";
 
 // Create a client - automatically authenticated using the OIDC token
-const client = QueueClient.fromVercelFunction();
+const client = await QueueClient.fromVercelFunction();
 
 // Create a topic with JSON serialization (default)
 const topic = createTopic<{ message: string; timestamp: number }>(
@@ -79,13 +85,18 @@ dotenv -e .env.local node index.ts
 
 ## Usage with Vercel
 
-When deploying on Vercel, rather than having a persistent server subscribed to a queue, Vercel can trigger a callback route when a message is ready for consumption.
+When deploying on Vercel, rather than having a persistent server subscribed to a
+queue, Vercel can trigger a callback route when a message is ready for
+consumption.
 
-To demonstrate using queues on Vercel, let's use a Next.js app. You can use an existing app or create one using [create-next-app](https://nextjs.org/docs/app/api-reference/cli/create-next-app).
+To demonstrate using queues on Vercel, let's use a Next.js app. You can use an
+existing app or create one using
+[create-next-app](https://nextjs.org/docs/app/api-reference/cli/create-next-app).
 
 ### TypeScript Configuration
 
-Update your `tsconfig.json` to use `"bundler"` module resolution for proper package export resolution:
+Update your `tsconfig.json` to use `"bundler"` module resolution for proper
+package export resolution:
 
 ```json
 {
@@ -104,7 +115,7 @@ Create a new server function to publish messages
 // app/action.ts
 "use server";
 
-import { QueueClient, createTopic } from "@vercel/queue";
+import { createTopic, QueueClient } from "@vercel/queue";
 
 export async function publishTestMessage(message: string) {
   // Initialize a queue client
@@ -121,12 +132,10 @@ export async function publishTestMessage(message: string) {
     { message, timestamp: Date.now() },
     {
       // Provide a callback URL to invoke a consumer when the message is ready to be processed
-      callbacks: {
-        webhook: {
-          url: process.env.VERCEL_PROJECT_PRODUCTION_URL
-            ? `https://${process.env.VERCEL_PROJECT_PRODUCTION_URL}/api/queue/handle`
-            : "http://localhost:3000/api/queue/handle",
-        },
+      callback: {
+        url: process.env.VERCEL_PROJECT_PRODUCTION_URL
+          ? `https://${process.env.VERCEL_PROJECT_PRODUCTION_URL}/api/queue/handle`
+          : "http://localhost:3000/api/queue/handle",
       },
     },
   );
@@ -154,65 +163,45 @@ export default function Button() {
 
 ### Consuming the queue
 
-Instead of running a persistent server that subscribes to the queue, we use the callback functionality of Vercel queues to consume messages on the fly, when a message is ready to be processed.
+Instead of running a persistent server that subscribes to the queue, we use the
+callback functionality of Vercel queues to consume messages on the fly, when a
+message is ready to be processed.
+
+The `handleCallback` helper function simplifies queue callback handling in NextJS:
 
 ```typescript
 // app/api/queue/handle/route.ts
-import { QueueClient, Topic, parseCallbackRequest } from "@vercel/queue";
-import { NextRequest } from "next/server";
-
-// Handle Vercel Queue callback requests
-export async function POST(request: NextRequest) {
-  try {
-    // Parse the queue callback information
-    const { queueName, consumerGroup, messageId } =
-      parseCallbackRequest(request);
-
-    // Create client
-    const client = await QueueClient.fromVercelFunction();
-
-    // Create topic and consumer group from the callback info
-    const topic = new Topic(client, queueName);
-    const cg = topic.consumerGroup(consumerGroup);
-
-    // Process the message
-    await cg.receiveMessage(messageId, async (message) => {
-      const payload = message.payload as { message: string; timestamp: number };
-      console.log(
-        `Received message "${payload.message}" (Sent at: ${payload.timestamp})`,
-      );
-    });
+import { handleCallback } from "@vercel/queue";
+
+export const POST = handleCallback({
+  // Handle messages sent on the "new-users" topic (the consumer
+  // group "default" will be used)
+  "my-topic": (message, metadata) => {
+    console.log(`Received message:`, message, metadata);
+    // metadata: { messageId, deliveryCount, timestamp }
+  },
+});
 
-    return Response.json({ status: "success" });
-  } catch (error) {
-    console.error("Webhook error:", error);
-    return Response.json(
-      { error: "Failed to process webhook" },
-      { status: 500 },
-    );
-  }
-}
+// Or, specify separate handlers for separate consumer groups
+export const POST = handleCallback({
+  // topic: "my-topic"
+  "my-topic": {
+    // consumer group: "compress"
+    compress: (message, metadata) => {
+      console.log("Compressing image:", message);
+    },
+    // consumer group: "resize"
+    resize: (message, metadata) => {
+      console.log("Resizing image:", message);
+    },
+    // consumer group: "watermark"
+    watermark: (message, metadata) => {
+      console.log("Adding watermark:", message);
+    },
+  },
+});
 ```
 
-> ![NOTE]
-> A single webhook handle can be used to process messages across various queues and consumer groups. Use the values of `queueName` and `consumerGroup` from `parseCallbackRequest()` to dynamically handle different code paths:
->
-> ```typescript
-> if (queueName === "upload-queue") {
->   processImageQueue(consumerGroup, message);
-> }
-> // ...
-> function processImageQueue(consumerGroup, message) {
->   if (consumerGroup === "compress") {
->     // handle image compression
->   }
->   // ...
-> }
-> // ...
-> ```
->
-> We are building an SDK to make queues and workflow easier to use. Reach out if you're interested.
-
 ## Key Features
 
 ### Streaming Support
@@ -261,12 +250,14 @@ const webhooks = topic.consumerGroup("webhooks");
 ## Architecture
 
 - **Topics**: Named message channels with configurable serialization
-- **Consumer Groups**: Named groups of consumers that process messages in parallel
+- **Consumer Groups**: Named groups of consumers that process messages in
+  parallel
   - `subscribe()`: Continuously process messages with automatic polling
   - `receiveMessage()`: Process a specific message by ID
   - `receiveNextMessage()`: Process the next available message (one-shot)
   - `handleMessage()`: Process message metadata only (without payload)
-- **Transports**: Pluggable serialization/deserialization for different data types
+- **Transports**: Pluggable serialization/deserialization for different data
+  types
 - **Streaming**: Memory-efficient processing of large payloads
 - **Visibility Timeouts**: Automatic message lifecycle management
 
@@ -277,20 +268,25 @@ The multipart parser is optimized for high-throughput scenarios:
 - **Streaming**: Messages are yielded immediately as headers are parsed
 - **Memory Efficient**: No buffering of complete payloads
 - **Fast Parsing**: Native Buffer operations for ~50% performance improvement
-- **Scalable**: Can handle arbitrarily large responses without memory constraints
+- **Scalable**: Can handle arbitrarily large responses without memory
+  constraints
 
 ## Serialization (Transport) System
 
-The queue client supports customizable serialization through the `Transport` interface with **streaming support** for memory-efficient processing. Transport can be configured at the **topic level** when creating a topic, or at the **consumer group level** when creating a consumer group.
+The queue client supports customizable serialization through the `Transport`
+interface with **streaming support** for memory-efficient processing. Transport
+can be configured at the **topic level** when creating a topic, or at the
+**consumer group level** when creating a consumer group.
 
 ### Built-in Transports
 
 #### JsonTransport (Default)
 
-Buffers data for JSON parsing - suitable for structured data that fits in memory.
+Buffers data for JSON parsing - suitable for structured data that fits in
+memory.
 
 ```typescript
-import { JsonTransport, createTopic } from "@vercel/queue";
+import { createTopic, JsonTransport } from "@vercel/queue";
 
 const topic = createTopic<{ data: any }>(
   client,
@@ -303,7 +299,8 @@ const topic = createTopic<{ data: any }>(client, "json-topic");
 
 #### BufferTransport
 
-Buffers the entire payload into memory as a Buffer - suitable for binary data that fits in memory.
+Buffers the entire payload into memory as a Buffer - suitable for binary data
+that fits in memory.
 
 ```typescript
 import { BufferTransport, createTopic } from "@vercel/queue";
@@ -319,10 +316,11 @@ await topic.publish(binaryData);
 
 #### StreamTransport
 
-**True streaming support** - passes ReadableStream directly without buffering. Ideal for large files and memory-efficient processing.
+**True streaming support** - passes ReadableStream directly without buffering.
+Ideal for large files and memory-efficient processing.
 
 ```typescript
-import { StreamTransport, createTopic } from "@vercel/queue";
+import { createTopic, StreamTransport } from "@vercel/queue";
 
 const topic = createTopic<ReadableStream<Uint8Array>>(
   client,
@@ -346,7 +344,8 @@ await topic.publish(fileStream);
 
 ### Custom Transport
 
-You can create your own serialization format by implementing the `Transport` interface:
+You can create your own serialization format by implementing the `Transport`
+interface:
 
 ```typescript
 import { Transport } from "@vercel/queue";
@@ -387,6 +386,21 @@ const topic = createTopic<T>(client, topicName, transport?);
 // Publish a message (uses topic's transport)
 await topic.publish(payload, options?);
 
+// Trigger a callback URL when the message is
+// ready for consumption
+await topic.publish(payload, {
+  callback: { url: "https://example.com/webhook" }
+});
+
+// Or provide multiple callbacks (each URL is called
+// with a separate consumer group)
+await topic.publish(payload, {
+  callback: {
+    group1: { url: "https://example.com/webhook1" },
+    group2: { url: "https://example.com/webhook2", delay: 30 }
+  }
+});
+
 // Create a consumer group (can override transport)
 const consumer = topic.consumerGroup<U>(groupName, options?);
 ```
@@ -445,6 +459,42 @@ interface CallbackMessageOptions {
   consumerGroup: string;
   messageId: string;
 }
+// Create a callback handler for NextJS route handlers
+function handleCallback(handlers: CallbackHandlers): (request: Request) => Promise<Response>;
+
+// Handler function signature for callbacks
+type Handler<T = unknown> = (
+  payload: T,
+  metadata: MessageMetadata
+) => Promise<MessageHandlerResult> | MessageHandlerResult;
+
+// Message metadata provided to handlers
+interface MessageMetadata {
+  messageId: string;
+  deliveryCount: number;
+  timestamp: string;
+}
+
+// Configuration object with handlers for different topics
+type CallbackHandlers = {
+  [topicName: string]:
+    | Handler // Single handler (uses 'default' consumer group)
+    | { [consumerGroup: string]: Handler }; // Multiple consumer group handlers
+};
+
+// Example usage:
+export const POST = handleCallback({
+  // Topic handler (uses 'default' consumer group)
+  "new-users": (message, metadata) => {
+    console.log(`New user event:`, message, metadata);
+  },
+
+  // Consumer group specific handlers
+  "image-processing": {
+    "compress": (message, metadata) => console.log("Compressing image", message),
+    "resize": (message, metadata) => console.log("Resizing image", message),
+  }
+});
 
 // Error thrown for invalid callback requests
 class InvalidCallbackError extends Error;
@@ -625,10 +675,11 @@ try {
 
 ### Complete Example: Video Processing Pipeline
 
-Here's a comprehensive example showing a video processing pipeline that processes videos with FFmpeg and stores the results in Vercel Blob:
+Here's a comprehensive example showing a video processing pipeline that
+processes videos with FFmpeg and stores the results in Vercel Blob:
 
 ```typescript
-import { QueueClient, createTopic, StreamTransport } from "@vercel/queue";
+import { createTopic, QueueClient, StreamTransport } from "@vercel/queue";
 import { spawn } from "child_process";
 import ffmpeg from "ffmpeg-static";
 import { put } from "@vercel/blob";
@@ -759,30 +810,39 @@ The queue client provides specific error types for different failure scenarios:
 
 ### Error Types
 
-- **`QueueEmptyError`**: Thrown when attempting to receive messages from an empty queue (204 status)
+- **`QueueEmptyError`**: Thrown when attempting to receive messages from an
+  empty queue (204 status)
 
   - Only thrown when directly using `client.receiveMessages()`
-  - `ConsumerGroup.subscribe()` handles this error internally and continues polling
+  - `ConsumerGroup.subscribe()` handles this error internally and continues
+    polling
 
-- **`MessageLockedError`**: Thrown when a message is temporarily locked (423 status)
+- **`MessageLockedError`**: Thrown when a message is temporarily locked (423
+  status)
 
   - Contains optional `retryAfter` property with seconds to wait before retry
-  - For `receiveMessages()` on FIFO queues: the next message in sequence is locked
+  - For `receiveMessages()` on FIFO queues: the next message in sequence is
+    locked
   - For `receiveMessageById()`: the requested message is locked
   - `ConsumerGroup.subscribe()` handles this error internally when polling
 
 - **`MessageNotFoundError`**: Message doesn't exist (404 status)
 
-- **`MessageNotAvailableError`**: Message exists but isn't available for processing (409 status)
+- **`MessageNotAvailableError`**: Message exists but isn't available for
+  processing (409 status)
 
-- **`FifoOrderingViolationError`**: FIFO queue ordering violation (409 status with nextMessageId)
+- **`FifoOrderingViolationError`**: FIFO queue ordering violation (409 status
+  with nextMessageId)
 
   - Contains `nextMessageId` property indicating which message to process first
 
-- **`FailedDependencyError`**: FIFO ordering violation when receiving by ID (424 status)
+- **`FailedDependencyError`**: FIFO ordering violation when receiving by ID (424
+  status)
 
-  - Contains `nextMessageId` property indicating which message must be processed first
-  - Similar to `FifoOrderingViolationError` but specifically for receive-by-ID operations
+  - Contains `nextMessageId` property indicating which message must be processed
+    first
+  - Similar to `FifoOrderingViolationError` but specifically for receive-by-ID
+    operations
 
 - **`MessageCorruptedError`**: Message data is corrupted or can't be parsed
 
@@ -805,14 +865,14 @@ The queue client provides specific error types for different failure scenarios:
 
 ```typescript
 import {
-  QueueEmptyError,
-  MessageLockedError,
-  FifoOrderingViolationError,
-  FailedDependencyError,
   BadRequestError,
-  UnauthorizedError,
+  FailedDependencyError,
+  FifoOrderingViolationError,
   ForbiddenError,
   InternalServerError,
+  MessageLockedError,
+  QueueEmptyError,
+  UnauthorizedError,
 } from "@vercel/queue";
 
 // Handle empty queue or locked messages

package/dist/index.d.mts

@@ -122,10 +122,12 @@ interface SendMessageOptions<T = unknown> {
      */
     retentionSeconds?: number;
     /**
-     * Consumer group callback configurations
-     * Format: { consumerGroup: { url, delay?, frequency? } }
+     * 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? }
      */
-    callbacks?: Record<string, CallbackConfig>;
+    callback?: Record<string, CallbackConfig> | CallbackConfig;
 }
 interface SendMessageResponse {
     /**
@@ -652,7 +654,7 @@ declare class Topic<T = unknown> {
     publish(payload: T, options?: {
         idempotencyKey?: string;
         retentionSeconds?: number;
-        callbacks?: Record<string, CallbackConfig>;
+        callback?: Record<string, CallbackConfig> | CallbackConfig;
     }): Promise<{
         messageId: string;
     }>;
@@ -719,7 +721,55 @@ declare function createTopic<T = unknown>(client: QueueClient, topicName: string
  * ```
  */
 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;
+    };
+};
+/**
+ * Simplified queue callback handler for NextJS route handlers
+ *
+ * @param handlers Object with topic-specific handlers
+ * @returns A NextJS route handler function
+ *
+ * @example
+ * ```typescript
+ * // Topic handler (uses 'default' consumer group)
+ * export const POST = handleCallback({
+ *   "new-users": (message, metadata) => {
+ *     console.log(`New user event:`, message, metadata);
+ *   }
+ * });
+ *
+ * // Consumer group specific handlers
+ * export const POST = handleCallback({
+ *   "image-processing": {
+ *     "compress": (message, metadata) => console.log("Compressing image", message),
+ *     "resize": (message, metadata) => console.log("Resizing image", message),
+ *   }
+ * });
+ * ```
+ */
+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, 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, parseCallbackRequest };
+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 };

package/dist/index.d.ts

@@ -122,10 +122,12 @@ interface SendMessageOptions<T = unknown> {
      */
     retentionSeconds?: number;
     /**
-     * Consumer group callback configurations
-     * Format: { consumerGroup: { url, delay?, frequency? } }
+     * 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? }
      */
-    callbacks?: Record<string, CallbackConfig>;
+    callback?: Record<string, CallbackConfig> | CallbackConfig;
 }
 interface SendMessageResponse {
     /**
@@ -652,7 +654,7 @@ declare class Topic<T = unknown> {
     publish(payload: T, options?: {
         idempotencyKey?: string;
         retentionSeconds?: number;
-        callbacks?: Record<string, CallbackConfig>;
+        callback?: Record<string, CallbackConfig> | CallbackConfig;
     }): Promise<{
         messageId: string;
     }>;
@@ -719,7 +721,55 @@ declare function createTopic<T = unknown>(client: QueueClient, topicName: string
  * ```
  */
 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;
+    };
+};
+/**
+ * Simplified queue callback handler for NextJS route handlers
+ *
+ * @param handlers Object with topic-specific handlers
+ * @returns A NextJS route handler function
+ *
+ * @example
+ * ```typescript
+ * // Topic handler (uses 'default' consumer group)
+ * export const POST = handleCallback({
+ *   "new-users": (message, metadata) => {
+ *     console.log(`New user event:`, message, metadata);
+ *   }
+ * });
+ *
+ * // Consumer group specific handlers
+ * export const POST = handleCallback({
+ *   "image-processing": {
+ *     "compress": (message, metadata) => console.log("Compressing image", message),
+ *     "resize": (message, metadata) => console.log("Resizing image", message),
+ *   }
+ * });
+ * ```
+ */
+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, 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, parseCallbackRequest };
+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 };