@vercel/queue 0.0.0-alpha.32 → 0.0.0-alpha.34

package/README.md

@@ -18,11 +18,6 @@ A TypeScript client library for interacting with the Vercel Queue Service API, d
 npm install @vercel/queue
 ```
 
-The package includes:
-
-- **Main Library**: Queue client and utilities for production and development
-- **CLI Tool**: `npx vercel-queue-local-init` for local development handler initialization
-
 ## Quick Start
 
 For local development, you'll need to set up your Vercel project:
@@ -42,15 +37,7 @@ vc env pull
 
 **Queues just work locally.** After you have setup your Vercel project, when you `send()` messages in development mode, they automatically trigger your handlers locally - no external queue infrastructure needed.
 
-### Next.js Lazy Loading
-
-For Next.js API routes (or others that are lazy-loaded), run this simple command to initialize handlers:
-
-```bash
-npx vercel-queue-local-init
-```
-
-That's it! The script reads your `vercel.json`, finds your queue handlers, and triggers Next.js to load them.
+The library reads your `vercel.json` configuration, discovers your queue handlers, and triggers them automatically when messages are sent.
 
 ### Example Workflow
 
@@ -58,22 +45,9 @@ That's it! The script reads your `vercel.json`, finds your queue handlers, and t
 # Start your dev server
 npm run dev
 
-# Initialize handlers (only needed for frameworks that lazy load routes in dev)
-npx vercel-queue-local-init
-
 # Send messages - they process locally automatically!
 ```
 
-### CLI Options
-
-```bash
-# Custom port
-npx vercel-queue-local-init --port 3001
-
-# Different config file
-npx vercel-queue-local-init --config ./my-vercel.json
-```
-
 ### TypeScript Configuration
 
 Update your `tsconfig.json` to use `"bundler"` module resolution for proper package export resolution:
@@ -157,23 +131,10 @@ export const POST = handleCallback({
   // Multiple consumers for different purposes
   "order-events": {
     fulfillment: async (order, metadata) => {
-      // By default, errors will trigger automatic retries
-      // But you can control retry timing if needed:
-      if (!isSystemReady()) {
-        // Override default retry with a 5 minute delay
-        return { timeoutSeconds: 300 };
-      }
-
       await processOrder(order);
     },
     analytics: async (order, metadata) => {
-      try {
-        await trackOrder(order);
-      } catch (error) {
-        // Optional: Custom exponential backoff instead of default retry timing
-        const timeoutSeconds = Math.pow(2, metadata.deliveryCount) * 60;
-        return { timeoutSeconds };
-      }
+      await trackOrder(order);
     },
   },
 });
@@ -198,9 +159,6 @@ export default handleCallback({
   },
   "order-events": {
     fulfillment: async (order, metadata) => {
-      if (!isSystemReady()) {
-        return { timeoutSeconds: 300 };
-      }
       await processOrder(order);
     },
     analytics: async (order, metadata) => {
@@ -392,14 +350,7 @@ await receive<T>(topicName, consumerGroup, handler, {
 type MessageHandler<T = unknown> = (
   message: T,
   metadata: MessageMetadata
-) => Promise<MessageHandlerResult> | MessageHandlerResult;
-
-// Handler result types
-type MessageHandlerResult = void | MessageTimeoutResult;
-
-interface MessageTimeoutResult {
-  timeoutSeconds: number; // seconds before message becomes available again
-}
+) => Promise<void> | void;
 ```
 
 ## Limits

package/dist/index.d.mts

@@ -1,82 +1,38 @@
-import { M as MessageHandler, C as ConsumerGroupOptions, P as PublishOptions, T as Transport } from './types-JvOenjfT.mjs';
-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.mjs';
+import { Q as QueueClientOptions, S as SendMessageOptions, T as Transport, a as SendMessageResponse, R as ReceiveMessagesOptions, M as Message, b as ReceiveMessageByIdOptions, c as ReceiveMessageByIdResponse, D as DeleteMessageOptions, d as DeleteMessageResponse, C as ChangeVisibilityOptions, e as ChangeVisibilityResponse, f as MessageHandler, P as PublishOptions, g as ConsumerGroupOptions } from './types-BHtRP_i_.mjs';
+export { i as BadRequestError, B as BufferTransport, j as ConcurrencyLimitError, k as ConsumerDiscoveryError, l as ConsumerRegistryNotConfiguredError, m as DuplicateMessageError, F as ForbiddenError, I as InternalServerError, n as InvalidLimitError, J as JsonTransport, o as MessageAlreadyProcessedError, p as MessageCorruptedError, q as MessageLockedError, u as MessageMetadata, r as MessageNotAvailableError, s as MessageNotFoundError, t as QueueEmptyError, h as StreamTransport, U as UnauthorizedError } from './types-BHtRP_i_.mjs';
 
-/**
- * Options for the consume method
- */
-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;
-}
-
-/**
- * Options for the send function
- */
-interface SendOptions<T = unknown> extends PublishOptions {
+declare class QueueClient {
+    private baseUrl;
+    private basePath;
+    private customHeaders;
+    private providedToken?;
+    private defaultDeploymentId?;
+    private pinToDeployment;
+    constructor(options?: QueueClientOptions);
+    private getSendDeploymentId;
+    private getConsumeDeploymentId;
+    private getToken;
+    private buildUrl;
+    private fetch;
+    sendMessage<T = unknown>(options: SendMessageOptions<T>, transport: Transport<T>): Promise<SendMessageResponse>;
+    receiveMessages<T = unknown>(options: ReceiveMessagesOptions<T>, transport: Transport<T>): AsyncGenerator<Message<T>, void, unknown>;
+    receiveMessageById<T = unknown>(options: ReceiveMessageByIdOptions<T>, transport: Transport<T>): Promise<ReceiveMessageByIdResponse<T>>;
+    deleteMessage(options: DeleteMessageOptions): Promise<DeleteMessageResponse>;
+    changeVisibility(options: ChangeVisibilityOptions): Promise<ChangeVisibilityResponse>;
     /**
-     * Serializer/deserializer for the payload
-     * @default JsonTransport instance
+     * 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
      */
-    transport?: Transport<T>;
-}
-/**
- * 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 function send<T = unknown>(topicName: string, payload: T, options?: SendOptions<T>): Promise<{
-    messageId: string;
-}>;
-/**
- * Options for the receive function
- */
-interface ReceiveOptions<T = unknown> extends ConsumerGroupOptions<T>, ConsumeOptions {
+    changeVisibilityAlt(options: ChangeVisibilityOptions): Promise<ChangeVisibilityResponse>;
 }
+
 /**
- * Receive a message from a topic (shorthand for topic and consumer group creation)
- * Uses the default QueueClient with automatic OIDC token detection
- * @param topicName Name of the topic to receive from
- * @param consumerGroup Name of the consumer group
- * @param handler Function to process the message
- * @returns Promise that resolves when the message is processed
- * @throws All the same errors as the underlying client methods
- */
-declare function receive<T = unknown>(topicName: string, consumerGroup: string, handler: MessageHandler<T>, options?: ReceiveOptions<T>): Promise<void>;
-/**
- * Receive a specific message by its ID with full payload
- * @param topicName Name of the topic to receive from
- * @param consumerGroup Name of the consumer group
- * @param handler Function to process the message
- * @param options Receive options with messageId specified
- * @returns Promise that resolves when the message is processed
- * @throws All the same errors as the underlying client methods
- */
-declare function receive<T = unknown>(topicName: string, consumerGroup: string, handler: MessageHandler<T>, options: ReceiveOptions<T> & {
-    messageId: string;
-    skipPayload?: false | undefined;
-}): Promise<void>;
-/**
- * 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
+ * Queue Callback utilities for handling incoming webhook payloads from Vercel triggers
  */
-declare function receive<T = unknown>(topicName: string, consumerGroup: string, handler: MessageHandler<void>, options: ReceiveOptions<T> & {
-    messageId: string;
-    skipPayload: true;
-}): Promise<void>;
 
 /**
  * Configuration object with handlers for different topics and consumer groups
@@ -129,6 +85,7 @@ declare function parseCallback(request: Request): Promise<ParsedCallbackRequest>
  * and routes to the appropriate handler based on topic and consumer group.
  *
  * @param handlers Object with topic-specific handlers organized by consumer groups
+ * @param client Optional QueueClient instance to use. If not provided, a default client is created.
  * @returns A Next.js route handler function
  *
  * @example
@@ -154,6 +111,158 @@ declare function parseCallback(request: Request): Promise<ParsedCallbackRequest>
  * });
  * ```
  */
-declare function handleCallback(handlers: CallbackHandlers): (request: Request) => Promise<Response>;
+declare function handleCallback(handlers: CallbackHandlers, client?: QueueClient): (request: Request) => Promise<Response>;
+
+/**
+ * Client - User-facing wrapper for the Vercel Queue Service
+ *
+ * This provides a simple interface with send() and handleCallback() methods
+ * while delegating to the internal QueueClient and factory functions.
+ */
+
+/**
+ * Client provides a simple interface to the Vercel Queue Service.
+ *
+ * @example
+ * ```typescript
+ * // Create a client with custom options
+ * const client = new Client({
+ *   token: "my-token",
+ *   headers: { "X-Custom": "header" },
+ * });
+ *
+ * // Send a message
+ * await client.send("my-topic", { hello: "world" });
+ *
+ * // Handle callbacks
+ * export const POST = client.handleCallback({
+ *   "my-topic": {
+ *     "my-group": async (msg, meta) => console.log(msg),
+ *   },
+ * });
+ * ```
+ */
+declare class Client {
+    private client;
+    /**
+     * Create a new Client
+     * @param options QueueClient configuration options
+     */
+    constructor(options?: QueueClientOptions);
+    /**
+     * Send a message to a topic
+     * @param topicName Name of the topic to send to
+     * @param payload The data to send
+     * @param options Optional publish options and transport
+     * @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
+     */
+    send<T = unknown>(topicName: string, payload: T, options?: PublishOptions & {
+        transport?: Transport<T>;
+    }): Promise<{
+        messageId: string;
+    }>;
+    /**
+     * Create a callback handler for processing queue messages
+     * Returns a Next.js route handler function that routes messages to appropriate handlers
+     * @param handlers Object with topic-specific handlers organized by consumer groups
+     * @returns A Next.js route handler function
+     *
+     * @example
+     * ```typescript
+     * export const POST = client.handleCallback({
+     *   "user-events": {
+     *     "welcome": (user, metadata) => console.log("Welcoming user", user),
+     *     "analytics": (user, metadata) => console.log("Tracking user", user),
+     *   },
+     * });
+     * ```
+     */
+    handleCallback(handlers: CallbackHandlers): (request: Request) => Promise<Response>;
+}
+
+/**
+ * Options for the consume method
+ */
+interface ConsumeOptions {
+    /** The specific message ID to consume (if not provided, consumes next available message) */
+    messageId?: string;
+}
+
+/**
+ * Options for the send function
+ */
+interface SendOptions<T = unknown> extends PublishOptions {
+    /**
+     * Serializer/deserializer for the payload
+     * @default JsonTransport instance
+     */
+    transport?: Transport<T>;
+    /**
+     * QueueClient instance to use for sending the message
+     * If not provided, a default client is created
+     */
+    client?: QueueClient;
+}
+/**
+ * Send a message to a topic (shorthand for topic creation and publishing)
+ * Uses the default QueueClient with automatic OIDC token detection, or a provided client
+ * @param topicName Name of the topic to send to
+ * @param payload The data to send
+ * @param options Optional send options including transport, publish settings, and client
+ * @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
+ *
+ * @example
+ * ```typescript
+ * // Using default client (OIDC token)
+ * await send("my-topic", { hello: "world" });
+ *
+ * // Using custom client
+ * const client = new QueueClient({ token: "my-token" });
+ * await send("my-topic", { hello: "world" }, { client });
+ * ```
+ */
+declare function send<T = unknown>(topicName: string, payload: T, options?: SendOptions<T>): Promise<{
+    messageId: string;
+}>;
+/**
+ * Options for the receive function
+ */
+interface ReceiveOptions<T = unknown> extends ConsumerGroupOptions<T>, ConsumeOptions {
+    /**
+     * QueueClient instance to use for receiving the message
+     * If not provided, a default client is created
+     */
+    client?: QueueClient;
+}
+/**
+ * Receive a message from a topic (shorthand for topic and consumer group creation)
+ * Uses the default QueueClient with automatic OIDC token detection
+ * @param topicName Name of the topic to receive from
+ * @param consumerGroup Name of the consumer group
+ * @param handler Function to process the message
+ * @returns Promise that resolves when the message is processed
+ * @throws All the same errors as the underlying client methods
+ */
+declare function receive<T = unknown>(topicName: string, consumerGroup: string, handler: MessageHandler<T>, options?: ReceiveOptions<T>): Promise<void>;
+/**
+ * Receive a specific message by its ID
+ * @param topicName Name of the topic to receive from
+ * @param consumerGroup Name of the consumer group
+ * @param handler Function to process the message
+ * @param options Receive options with messageId specified
+ * @returns Promise that resolves when the message is processed
+ * @throws All the same errors as the underlying client methods
+ */
+declare function receive<T = unknown>(topicName: string, consumerGroup: string, handler: MessageHandler<T>, options: ReceiveOptions<T> & {
+    messageId: string;
+}): Promise<void>;
 
-export { MessageHandler, type ParsedCallbackRequest, PublishOptions, type ReceiveOptions, type SendOptions, Transport, handleCallback, parseCallback, receive, send };
+export { type CallbackHandlers, Client, Message, MessageHandler, type ParsedCallbackRequest, PublishOptions, QueueClientOptions, type ReceiveOptions, SendMessageOptions, SendMessageResponse, type SendOptions, Transport, handleCallback, parseCallback, receive, send };

package/dist/index.d.ts

@@ -1,82 +1,38 @@
-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';
+import { Q as QueueClientOptions, S as SendMessageOptions, T as Transport, a as SendMessageResponse, R as ReceiveMessagesOptions, M as Message, b as ReceiveMessageByIdOptions, c as ReceiveMessageByIdResponse, D as DeleteMessageOptions, d as DeleteMessageResponse, C as ChangeVisibilityOptions, e as ChangeVisibilityResponse, f as MessageHandler, P as PublishOptions, g as ConsumerGroupOptions } from './types-BHtRP_i_.js';
+export { i as BadRequestError, B as BufferTransport, j as ConcurrencyLimitError, k as ConsumerDiscoveryError, l as ConsumerRegistryNotConfiguredError, m as DuplicateMessageError, F as ForbiddenError, I as InternalServerError, n as InvalidLimitError, J as JsonTransport, o as MessageAlreadyProcessedError, p as MessageCorruptedError, q as MessageLockedError, u as MessageMetadata, r as MessageNotAvailableError, s as MessageNotFoundError, t as QueueEmptyError, h as StreamTransport, U as UnauthorizedError } from './types-BHtRP_i_.js';
 
-/**
- * Options for the consume method
- */
-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;
-}
-
-/**
- * Options for the send function
- */
-interface SendOptions<T = unknown> extends PublishOptions {
+declare class QueueClient {
+    private baseUrl;
+    private basePath;
+    private customHeaders;
+    private providedToken?;
+    private defaultDeploymentId?;
+    private pinToDeployment;
+    constructor(options?: QueueClientOptions);
+    private getSendDeploymentId;
+    private getConsumeDeploymentId;
+    private getToken;
+    private buildUrl;
+    private fetch;
+    sendMessage<T = unknown>(options: SendMessageOptions<T>, transport: Transport<T>): Promise<SendMessageResponse>;
+    receiveMessages<T = unknown>(options: ReceiveMessagesOptions<T>, transport: Transport<T>): AsyncGenerator<Message<T>, void, unknown>;
+    receiveMessageById<T = unknown>(options: ReceiveMessageByIdOptions<T>, transport: Transport<T>): Promise<ReceiveMessageByIdResponse<T>>;
+    deleteMessage(options: DeleteMessageOptions): Promise<DeleteMessageResponse>;
+    changeVisibility(options: ChangeVisibilityOptions): Promise<ChangeVisibilityResponse>;
     /**
-     * Serializer/deserializer for the payload
-     * @default JsonTransport instance
+     * 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
      */
-    transport?: Transport<T>;
-}
-/**
- * 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 function send<T = unknown>(topicName: string, payload: T, options?: SendOptions<T>): Promise<{
-    messageId: string;
-}>;
-/**
- * Options for the receive function
- */
-interface ReceiveOptions<T = unknown> extends ConsumerGroupOptions<T>, ConsumeOptions {
+    changeVisibilityAlt(options: ChangeVisibilityOptions): Promise<ChangeVisibilityResponse>;
 }
+
 /**
- * Receive a message from a topic (shorthand for topic and consumer group creation)
- * Uses the default QueueClient with automatic OIDC token detection
- * @param topicName Name of the topic to receive from
- * @param consumerGroup Name of the consumer group
- * @param handler Function to process the message
- * @returns Promise that resolves when the message is processed
- * @throws All the same errors as the underlying client methods
- */
-declare function receive<T = unknown>(topicName: string, consumerGroup: string, handler: MessageHandler<T>, options?: ReceiveOptions<T>): Promise<void>;
-/**
- * Receive a specific message by its ID with full payload
- * @param topicName Name of the topic to receive from
- * @param consumerGroup Name of the consumer group
- * @param handler Function to process the message
- * @param options Receive options with messageId specified
- * @returns Promise that resolves when the message is processed
- * @throws All the same errors as the underlying client methods
- */
-declare function receive<T = unknown>(topicName: string, consumerGroup: string, handler: MessageHandler<T>, options: ReceiveOptions<T> & {
-    messageId: string;
-    skipPayload?: false | undefined;
-}): Promise<void>;
-/**
- * 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
+ * Queue Callback utilities for handling incoming webhook payloads from Vercel triggers
  */
-declare function receive<T = unknown>(topicName: string, consumerGroup: string, handler: MessageHandler<void>, options: ReceiveOptions<T> & {
-    messageId: string;
-    skipPayload: true;
-}): Promise<void>;
 
 /**
  * Configuration object with handlers for different topics and consumer groups
@@ -129,6 +85,7 @@ declare function parseCallback(request: Request): Promise<ParsedCallbackRequest>
  * and routes to the appropriate handler based on topic and consumer group.
  *
  * @param handlers Object with topic-specific handlers organized by consumer groups
+ * @param client Optional QueueClient instance to use. If not provided, a default client is created.
  * @returns A Next.js route handler function
  *
  * @example
@@ -154,6 +111,158 @@ declare function parseCallback(request: Request): Promise<ParsedCallbackRequest>
  * });
  * ```
  */
-declare function handleCallback(handlers: CallbackHandlers): (request: Request) => Promise<Response>;
+declare function handleCallback(handlers: CallbackHandlers, client?: QueueClient): (request: Request) => Promise<Response>;
+
+/**
+ * Client - User-facing wrapper for the Vercel Queue Service
+ *
+ * This provides a simple interface with send() and handleCallback() methods
+ * while delegating to the internal QueueClient and factory functions.
+ */
+
+/**
+ * Client provides a simple interface to the Vercel Queue Service.
+ *
+ * @example
+ * ```typescript
+ * // Create a client with custom options
+ * const client = new Client({
+ *   token: "my-token",
+ *   headers: { "X-Custom": "header" },
+ * });
+ *
+ * // Send a message
+ * await client.send("my-topic", { hello: "world" });
+ *
+ * // Handle callbacks
+ * export const POST = client.handleCallback({
+ *   "my-topic": {
+ *     "my-group": async (msg, meta) => console.log(msg),
+ *   },
+ * });
+ * ```
+ */
+declare class Client {
+    private client;
+    /**
+     * Create a new Client
+     * @param options QueueClient configuration options
+     */
+    constructor(options?: QueueClientOptions);
+    /**
+     * Send a message to a topic
+     * @param topicName Name of the topic to send to
+     * @param payload The data to send
+     * @param options Optional publish options and transport
+     * @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
+     */
+    send<T = unknown>(topicName: string, payload: T, options?: PublishOptions & {
+        transport?: Transport<T>;
+    }): Promise<{
+        messageId: string;
+    }>;
+    /**
+     * Create a callback handler for processing queue messages
+     * Returns a Next.js route handler function that routes messages to appropriate handlers
+     * @param handlers Object with topic-specific handlers organized by consumer groups
+     * @returns A Next.js route handler function
+     *
+     * @example
+     * ```typescript
+     * export const POST = client.handleCallback({
+     *   "user-events": {
+     *     "welcome": (user, metadata) => console.log("Welcoming user", user),
+     *     "analytics": (user, metadata) => console.log("Tracking user", user),
+     *   },
+     * });
+     * ```
+     */
+    handleCallback(handlers: CallbackHandlers): (request: Request) => Promise<Response>;
+}
+
+/**
+ * Options for the consume method
+ */
+interface ConsumeOptions {
+    /** The specific message ID to consume (if not provided, consumes next available message) */
+    messageId?: string;
+}
+
+/**
+ * Options for the send function
+ */
+interface SendOptions<T = unknown> extends PublishOptions {
+    /**
+     * Serializer/deserializer for the payload
+     * @default JsonTransport instance
+     */
+    transport?: Transport<T>;
+    /**
+     * QueueClient instance to use for sending the message
+     * If not provided, a default client is created
+     */
+    client?: QueueClient;
+}
+/**
+ * Send a message to a topic (shorthand for topic creation and publishing)
+ * Uses the default QueueClient with automatic OIDC token detection, or a provided client
+ * @param topicName Name of the topic to send to
+ * @param payload The data to send
+ * @param options Optional send options including transport, publish settings, and client
+ * @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
+ *
+ * @example
+ * ```typescript
+ * // Using default client (OIDC token)
+ * await send("my-topic", { hello: "world" });
+ *
+ * // Using custom client
+ * const client = new QueueClient({ token: "my-token" });
+ * await send("my-topic", { hello: "world" }, { client });
+ * ```
+ */
+declare function send<T = unknown>(topicName: string, payload: T, options?: SendOptions<T>): Promise<{
+    messageId: string;
+}>;
+/**
+ * Options for the receive function
+ */
+interface ReceiveOptions<T = unknown> extends ConsumerGroupOptions<T>, ConsumeOptions {
+    /**
+     * QueueClient instance to use for receiving the message
+     * If not provided, a default client is created
+     */
+    client?: QueueClient;
+}
+/**
+ * Receive a message from a topic (shorthand for topic and consumer group creation)
+ * Uses the default QueueClient with automatic OIDC token detection
+ * @param topicName Name of the topic to receive from
+ * @param consumerGroup Name of the consumer group
+ * @param handler Function to process the message
+ * @returns Promise that resolves when the message is processed
+ * @throws All the same errors as the underlying client methods
+ */
+declare function receive<T = unknown>(topicName: string, consumerGroup: string, handler: MessageHandler<T>, options?: ReceiveOptions<T>): Promise<void>;
+/**
+ * Receive a specific message by its ID
+ * @param topicName Name of the topic to receive from
+ * @param consumerGroup Name of the consumer group
+ * @param handler Function to process the message
+ * @param options Receive options with messageId specified
+ * @returns Promise that resolves when the message is processed
+ * @throws All the same errors as the underlying client methods
+ */
+declare function receive<T = unknown>(topicName: string, consumerGroup: string, handler: MessageHandler<T>, options: ReceiveOptions<T> & {
+    messageId: string;
+}): Promise<void>;
 
-export { MessageHandler, type ParsedCallbackRequest, PublishOptions, type ReceiveOptions, type SendOptions, Transport, handleCallback, parseCallback, receive, send };
+export { type CallbackHandlers, Client, Message, MessageHandler, type ParsedCallbackRequest, PublishOptions, QueueClientOptions, type ReceiveOptions, SendMessageOptions, SendMessageResponse, type SendOptions, Transport, handleCallback, parseCallback, receive, send };