iii-browser-sdk 0.17.0 → 0.18.0

package/dist/index.d.cts

@@ -1,664 +1,5 @@
-import { n as IStream } from "./stream-DUoMZNRq.cjs";
+import { A as OnTriggerRegistrationInput, C as AuthInput, D as MiddlewareFunctionInput, E as MessageType, F as RegisterTriggerMessage, I as RegisterTriggerTypeMessage, L as StreamChannelRef, M as OnTriggerTypeRegistrationInput, N as OnTriggerTypeRegistrationResult, O as OnFunctionRegistrationInput, P as RegisterFunctionMessage, R as TriggerAction$1, S as ChannelWriter, T as EnqueueResult, _ as IIIConnectionState, a as ISdk, c as RegisterTriggerInput, d as Trigger, f as TriggerTypeRef, g as EngineTriggers, h as EngineFunctions, i as FunctionRef, j as OnTriggerRegistrationResult, k as OnFunctionRegistrationResult, l as RegisterTriggerTypeInput, m as TriggerHandler, n as ApiResponse, o as RegisterFunctionInput, p as TriggerConfig, r as Channel, s as RegisterFunctionOptions, t as ApiRequest, u as RemoteFunctionHandler, v as IIIReconnectionConfig, w as AuthResult, x as ChannelReader, z as TriggerRequest } from "./types-CP-lPyex.cjs";
 
-//#region src/iii-types.d.ts
-declare enum MessageType {
-  RegisterFunction = "registerfunction",
-  UnregisterFunction = "unregisterfunction",
-  InvokeFunction = "invokefunction",
-  InvocationResult = "invocationresult",
-  RegisterTriggerType = "registertriggertype",
-  RegisterTrigger = "registertrigger",
-  UnregisterTrigger = "unregistertrigger",
-  UnregisterTriggerType = "unregistertriggertype",
-  TriggerRegistrationResult = "triggerregistrationresult",
-  WorkerRegistered = "workerregistered"
-}
-type RegisterTriggerTypeMessage = {
-  message_type: MessageType.RegisterTriggerType;
-  id: string;
-  description: string;
-};
-type RegisterTriggerMessage = {
-  message_type: MessageType.RegisterTrigger;
-  id: string;
-  type: string;
-  function_id: string;
-  config: unknown;
-};
-type RegisterFunctionFormat = {
-  /**
-   * The name of the parameter
-   */
-  name?: string;
-  /**
-   * The description of the parameter
-   */
-  description?: string;
-  /**
-   * The type of the parameter
-   */
-  type?: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'null' | 'map' | 'integer';
-  /**
-   * The body of the parameter (for objects)
-   */
-  properties?: Record<string, unknown>;
-  /**
-   * The items of the parameter (for arrays)
-   */
-  items?: unknown;
-  /**
-   * Whether the parameter is required
-   */
-  required?: string[];
-  [key: string]: unknown;
-};
-type RegisterFunctionMessage = {
-  message_type: MessageType.RegisterFunction;
-  /**
-   * The path of the function (use :: for namespacing, e.g. external::my_lambda)
-   */
-  id: string;
-  /**
-   * The description of the function
-   */
-  description?: string;
-  /**
-   * The request format of the function
-   */
-  request_format?: RegisterFunctionFormat;
-  /**
-   * The response format of the function
-   */
-  response_format?: RegisterFunctionFormat;
-  metadata?: Record<string, unknown>;
-};
-/**
- * Routing action for {@link TriggerRequest}. Determines how the engine
- * handles the invocation.
- *
- * - `enqueue` -- Routes through a named queue for async processing.
- * - `void` -- Fire-and-forget, no response.
- */
-type TriggerAction$1 = {
-  type: 'enqueue';
-  queue: string;
-} | {
-  type: 'void';
-};
-/**
- * Input passed to the RBAC auth function during WebSocket upgrade.
- * Contains the HTTP headers, query parameters, and client IP from the
- * connecting worker's upgrade request.
- */
-type AuthInput = {
-  /** HTTP headers from the WebSocket upgrade request. */headers: Record<string, string>; /** Query parameters from the upgrade URL. Each key maps to an array of values to support repeated keys. */
-  query_params: Record<string, string[]>; /** IP address of the connecting client. */
-  ip_address: string;
-};
-/**
- * Return value from the RBAC auth function. Controls which functions the
- * authenticated worker can invoke and what context is forwarded to the
- * middleware.
- */
-type AuthResult = {
-  /** Additional function IDs to allow beyond the `expose_functions` config. */allowed_functions: string[]; /** Function IDs to deny even if they match `expose_functions`. Takes precedence over allowed. */
-  forbidden_functions: string[]; /** Trigger type IDs the worker may register triggers for. When omitted, all types are allowed. */
-  allowed_trigger_types?: string[]; /** Whether the worker may register new trigger types. */
-  allow_trigger_type_registration: boolean; /** Whether the worker may register new functions. Defaults to `true` if omitted. */
-  allow_function_registration?: boolean; /** Arbitrary context forwarded to the middleware function on every invocation. */
-  context: Record<string, unknown>; /** Optional prefix applied to all function IDs registered by this worker. */
-  function_registration_prefix?: string;
-};
-/**
- * Input passed to the RBAC middleware function on every function invocation
- * through the RBAC port. The middleware can inspect, modify, or reject the
- * call before it reaches the target function.
- */
-type MiddlewareFunctionInput = {
-  /** ID of the function being invoked. */function_id: string; /** Payload sent by the caller. */
-  payload: Record<string, unknown>; /** Routing action, if any. */
-  action?: TriggerAction$1; /** Auth context returned by the auth function for this session. */
-  context: Record<string, unknown>;
-};
-/**
- * Input passed to the `on_trigger_type_registration_function_id` hook
- * when a worker attempts to register a new trigger type through the RBAC port.
- * Return an {@link OnTriggerTypeRegistrationResult} with the (possibly mapped)
- * fields, or throw to deny the registration.
- */
-type OnTriggerTypeRegistrationInput = {
-  /** ID of the trigger type being registered. */trigger_type_id: string; /** Human-readable description of the trigger type. */
-  description: string; /** Auth context from `AuthResult.context` for this session. */
-  context: Record<string, unknown>;
-};
-/**
- * Result returned from the `on_trigger_type_registration_function_id` hook.
- * All fields are optional -- omitted fields keep the original value from the
- * registration request.
- */
-type OnTriggerTypeRegistrationResult = {
-  /** Mapped trigger type ID. */trigger_type_id?: string; /** Mapped description. */
-  description?: string;
-};
-/**
- * Input passed to the `on_trigger_registration_function_id` hook
- * when a worker attempts to register a trigger through the RBAC port.
- * Return an {@link OnTriggerRegistrationResult} with the (possibly mapped)
- * fields, or throw to deny the registration.
- */
-type OnTriggerRegistrationInput = {
-  /** ID of the trigger being registered. */trigger_id: string; /** Trigger type identifier. */
-  trigger_type: string; /** ID of the function this trigger is bound to. */
-  function_id: string; /** Trigger-specific configuration. */
-  config: unknown; /** Auth context from `AuthResult.context` for this session. */
-  context: Record<string, unknown>;
-};
-/**
- * Result returned from the `on_trigger_registration_function_id` hook.
- * All fields are optional -- omitted fields keep the original value from the
- * registration request.
- */
-type OnTriggerRegistrationResult = {
-  /** Mapped trigger ID. */trigger_id?: string; /** Mapped trigger type. */
-  trigger_type?: string; /** Mapped function ID. */
-  function_id?: string; /** Mapped trigger configuration. */
-  config?: unknown;
-};
-/**
- * Input passed to the `on_function_registration_function_id` hook
- * when a worker attempts to register a function through the RBAC port.
- * Return an {@link OnFunctionRegistrationResult} with the (possibly mapped)
- * fields, or throw to deny the registration.
- */
-type OnFunctionRegistrationInput = {
-  /** ID of the function being registered. */function_id: string; /** Human-readable description of the function. */
-  description?: string; /** Arbitrary metadata attached to the function. */
-  metadata?: Record<string, unknown>; /** Auth context from `AuthResult.context` for this session. */
-  context: Record<string, unknown>;
-};
-/**
- * Result returned from the `on_function_registration_function_id` hook.
- * All fields are optional -- omitted fields keep the original value from the
- * registration request.
- */
-type OnFunctionRegistrationResult = {
-  /** Mapped function ID. */function_id?: string; /** Mapped description. */
-  description?: string; /** Mapped metadata. */
-  metadata?: Record<string, unknown>;
-};
-/**
- * Result returned when a function is invoked with `TriggerAction.Enqueue`.
- */
-type EnqueueResult = {
-  /** Unique receipt ID for the enqueued message. */messageReceiptId: string;
-};
-/**
- * Request object passed to {@link ISdk.trigger}.
- *
- * @typeParam TInput - Type of the payload.
- */
-type TriggerRequest<TInput = unknown> = {
-  /** ID of the function to invoke. */function_id: string; /** Payload to pass to the function. */
-  payload: TInput; /** Routing action. Omit for synchronous request/response. */
-  action?: TriggerAction$1; /** Override the default invocation timeout in milliseconds. */
-  timeoutMs?: number;
-};
-/**
- * Serializable reference to one end of a streaming channel. Can be included
- * in invocation payloads to pass channel endpoints between workers.
- */
-type StreamChannelRef = {
-  /** Unique channel identifier. */channel_id: string; /** Access key for authentication. */
-  access_key: string; /** Whether this ref is for reading or writing. */
-  direction: 'read' | 'write';
-};
-//#endregion
-//#region src/channels.d.ts
-/**
- * Write end of a streaming channel. Uses native browser WebSocket.
- *
- * @example
- * ```typescript
- * const channel = await iii.createChannel()
- *
- * channel.writer.sendMessage(JSON.stringify({ type: 'event', data: 'test' }))
- * channel.writer.sendBinary(new Uint8Array([1, 2, 3]))
- * channel.writer.close()
- * ```
- */
-declare class ChannelWriter {
-  private static readonly FRAME_SIZE;
-  private ws;
-  private wsReady;
-  private readonly pendingMessages;
-  private readonly url;
-  constructor(engineWsBase: string, ref: StreamChannelRef);
-  private ensureConnected;
-  /** Send a text message through the channel. */
-  sendMessage(msg: string): void;
-  /** Send binary data through the channel. */
-  sendBinary(data: Uint8Array): void;
-  /** Close the channel writer. */
-  close(): void;
-  private sendRaw;
-}
-/**
- * Read end of a streaming channel. Uses native browser WebSocket.
- *
- * @example
- * ```typescript
- * const channel = await iii.createChannel()
- *
- * channel.reader.onMessage((msg) => console.log('Got:', msg))
- * channel.reader.onBinary((data) => console.log('Binary:', data.byteLength))
- * ```
- */
-declare class ChannelReader {
-  private ws;
-  private connected;
-  private readonly messageCallbacks;
-  private readonly binaryCallbacks;
-  private readonly url;
-  constructor(engineWsBase: string, ref: StreamChannelRef);
-  private ensureConnected;
-  /** Register a callback to receive text messages from the channel. */
-  onMessage(callback: (msg: string) => void): void;
-  /** Register a callback to receive binary data from the channel. */
-  onBinary(callback: (data: Uint8Array) => void): void;
-  /** Read all binary data from the channel until it closes. */
-  readAll(): Promise<Uint8Array>;
-  /** Close the channel reader. */
-  close(): void;
-}
-//#endregion
-//#region src/iii-constants.d.ts
-/**
- * Constants for the III module.
- */
-/**
- * Engine function paths for internal operations.
- *
- * Naming note: `LIST_TRIGGERS` / `INFO_TRIGGERS` cover trigger TYPES
- * (templates). `LIST_REGISTERED_TRIGGERS` / `INFO_REGISTERED_TRIGGERS`
- * cover trigger INSTANCES (subscriber rows). The old
- * `engine::trigger-types::list` builtin has been removed and is now
- * served by `engine::triggers::list`.
- */
-declare const EngineFunctions: {
-  readonly LIST_FUNCTIONS: "engine::functions::list";
-  readonly INFO_FUNCTIONS: "engine::functions::info";
-  readonly LIST_WORKERS: "engine::workers::list";
-  readonly INFO_WORKERS: "engine::workers::info";
-  readonly LIST_TRIGGERS: "engine::triggers::list";
-  readonly INFO_TRIGGERS: "engine::triggers::info";
-  readonly LIST_REGISTERED_TRIGGERS: "engine::registered-triggers::list";
-  readonly INFO_REGISTERED_TRIGGERS: "engine::registered-triggers::info";
-  readonly REGISTER_WORKER: "engine::workers::register";
-};
-/** Engine trigger types */
-declare const EngineTriggers: {
-  readonly FUNCTIONS_AVAILABLE: "engine::functions-available";
-};
-/** Connection state for the III WebSocket */
-type IIIConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'failed';
-/** Configuration for WebSocket reconnection behavior */
-interface IIIReconnectionConfig {
-  /** Starting delay in milliseconds (default: 1000ms) */
-  initialDelayMs: number;
-  /** Maximum delay cap in milliseconds (default: 30000ms) */
-  maxDelayMs: number;
-  /** Exponential backoff multiplier (default: 2) */
-  backoffMultiplier: number;
-  /** Random jitter factor 0-1 (default: 0.3) */
-  jitterFactor: number;
-  /** Maximum retry attempts, -1 for infinite (default: -1) */
-  maxRetries: number;
-}
-//#endregion
-//#region src/triggers.d.ts
-/**
- * Configuration passed to a trigger handler when a trigger instance is
- * registered or unregistered.
- *
- * @typeParam TConfig - Type of the trigger-specific configuration.
- */
-type TriggerConfig<TConfig> = {
-  /** Trigger instance ID. */id: string; /** Function to invoke when the trigger fires. */
-  function_id: string; /** Trigger-specific configuration. */
-  config: TConfig;
-};
-/**
- * Handler interface for custom trigger types. Passed to
- * `ISdk.registerTriggerType`.
- *
- * @typeParam TConfig - Type of the trigger-specific configuration.
- *
- * @example
- * ```typescript
- * const handler: TriggerHandler<{ interval: number }> = {
- *   async registerTrigger({ id, function_id, config }) {
- *     // Set up periodic invocation
- *   },
- *   async unregisterTrigger({ id, function_id, config }) {
- *     // Clean up
- *   },
- * }
- * ```
- */
-type TriggerHandler<TConfig> = {
-  /** Called when a trigger instance is registered. */registerTrigger(config: TriggerConfig<TConfig>): Promise<void>; /** Called when a trigger instance is unregistered. */
-  unregisterTrigger(config: TriggerConfig<TConfig>): Promise<void>;
-};
-//#endregion
-//#region src/types.d.ts
-/**
- * Async function handler for a registered function. Receives the invocation
- * payload and returns the result.
- *
- * @typeParam TInput - Type of the invocation payload.
- * @typeParam TOutput - Type of the return value.
- *
- * @example
- * ```typescript
- * const handler: RemoteFunctionHandler<{ name: string }, { message: string }> =
- *   async (data) => ({ message: `Hello, ${data.name}!` })
- * ```
- */
-type RemoteFunctionHandler<TInput = any, TOutput = any> = (data: TInput) => Promise<TOutput>;
-type RegisterTriggerInput = Omit<RegisterTriggerMessage, 'message_type' | 'id'>;
-type RegisterFunctionInput = Omit<RegisterFunctionMessage, 'message_type'>;
-type RegisterFunctionOptions = Omit<RegisterFunctionMessage, 'message_type' | 'id'>;
-type RegisterTriggerTypeInput = Omit<RegisterTriggerTypeMessage, 'message_type'>;
-interface ISdk {
-  /**
-   * Registers a new trigger. A trigger is a way to invoke a function when a certain event occurs.
-   * @param trigger - The trigger to register
-   * @returns A trigger object that can be used to unregister the trigger
-   *
-   * @example
-   * ```typescript
-   * const trigger = iii.registerTrigger({
-   *   type: 'cron',
-   *   function_id: 'my-service::process-batch',
-   *   config: { expression: '0 *\/5 * * * * *' },
-   * })
-   *
-   * // Later, remove the trigger
-   * trigger.unregister()
-   * ```
-   */
-  registerTrigger(trigger: RegisterTriggerInput): Trigger;
-  /**
-   * Registers a new function with a local handler or an HTTP invocation config.
-   * @param functionId - Unique function identifier
-   * @param handler - Async handler for local execution, or an HTTP invocation config for external functions (Lambda, Cloudflare Workers, etc.)
-   * @param options - Optional function registration options (description, request/response formats, metadata)
-   * @returns A handle that can be used to unregister the function
-   *
-   * @example
-   * ```typescript
-   * // Local handler
-   * const ref = iii.registerFunction(
-   *   'greet',
-   *   async (data: { name: string }) => ({ message: `Hello, ${data.name}!` }),
-   *   { description: 'Returns a greeting' },
-   * )
-   *
-   * // Later, remove the function
-   * ref.unregister()
-   * ```
-   */
-  registerFunction(functionId: string, handler: RemoteFunctionHandler, options?: RegisterFunctionOptions): FunctionRef;
-  /**
-   * Invokes a function using a request object.
-   *
-   * @param request - The trigger request containing function_id, payload, and optional action/timeout
-   * @returns The result of the function
-   *
-   * @example
-   * ```typescript
-   * // Synchronous invocation
-   * const result = await iii.trigger<{ name: string }, { message: string }>({
-   *   function_id: 'greet',
-   *   payload: { name: 'World' },
-   *   timeoutMs: 5000,
-   * })
-   * console.log(result.message) // "Hello, World!"
-   *
-   * // Fire-and-forget
-   * await iii.trigger({
-   *   function_id: 'send-email',
-   *   payload: { to: 'user@example.com' },
-   *   action: TriggerAction.Void(),
-   * })
-   *
-   * // Enqueue for async processing
-   * const receipt = await iii.trigger({
-   *   function_id: 'process-order',
-   *   payload: { orderId: '123' },
-   *   action: TriggerAction.Enqueue({ queue: 'orders' }),
-   * })
-   * ```
-   */
-  trigger<TInput, TOutput>(request: TriggerRequest<TInput>): Promise<TOutput>;
-  /**
-   * Registers a new trigger type. A trigger type is a way to invoke a function when a certain event occurs.
-   * @param triggerType - The trigger type to register
-   * @param handler - The handler for the trigger type
-   * @returns A trigger type object that can be used to unregister the trigger type
-   *
-   * @example
-   * ```typescript
-   * type CronConfig = { expression: string }
-   *
-   * iii.registerTriggerType<CronConfig>(
-   *   { id: 'cron', description: 'Fires on a cron schedule' },
-   *   {
-   *     async registerTrigger({ id, function_id, config }) {
-   *       startCronJob(id, config.expression, () =>
-   *         iii.trigger({ function_id, payload: {} }),
-   *       )
-   *     },
-   *     async unregisterTrigger({ id }) {
-   *       stopCronJob(id)
-   *     },
-   *   },
-   * )
-   * ```
-   */
-  registerTriggerType<TConfig>(triggerType: RegisterTriggerTypeInput, handler: TriggerHandler<TConfig>): TriggerTypeRef<TConfig>;
-  /**
-   * Unregisters a trigger type.
-   * @param triggerType - The trigger type to unregister
-   *
-   * @example
-   * ```typescript
-   * iii.unregisterTriggerType({ id: 'cron', description: 'Fires on a cron schedule' })
-   * ```
-   */
-  unregisterTriggerType(triggerType: RegisterTriggerTypeInput): void;
-  /**
-   * Creates a streaming channel pair for worker-to-worker data transfer.
-   * Returns a Channel with a local writer/reader and serializable refs that
-   * can be passed as fields in the invocation data to other functions.
-   *
-   * @param bufferSize - Optional buffer size for the channel (default: 64)
-   * @returns A Channel with writer, reader, and their serializable refs
-   *
-   * @example
-   * ```typescript
-   * const channel = await iii.createChannel()
-   *
-   * // Pass the writer ref to another function
-   * await iii.trigger({
-   *   function_id: 'stream-producer',
-   *   payload: { outputChannel: channel.writerRef },
-   * })
-   *
-   * // Read data locally
-   * channel.reader.onMessage((msg) => {
-   *   console.log('Received:', msg)
-   * })
-   * ```
-   */
-  createChannel(bufferSize?: number): Promise<Channel>;
-  /**
-   * Creates a new stream implementation.
-   *
-   * This overrides the default stream implementation.
-   *
-   * @param streamName - The name of the stream
-   * @param stream - The stream implementation
-   *
-   * @example
-   * ```typescript
-   * iii.createStream('sessions', {
-   *   async get({ group_id, item_id }) { return null },
-   *   async set({ group_id, item_id, data }) { return { new_value: data } },
-   *   async delete({ group_id, item_id }) { return {} },
-   *   async list({ group_id }) { return [] },
-   *   async listGroups() { return [] },
-   *   async update() { return null },
-   * })
-   * ```
-   */
-  createStream<TData>(streamName: string, stream: IStream<TData>): void;
-  /**
-   * Gracefully shutdown the iii, cleaning up all resources.
-   *
-   * @example
-   * ```typescript
-   * await iii.shutdown()
-   * ```
-   */
-  shutdown(): Promise<void>;
-  /**
-   * Subscribe to connection-state transitions. The handler is fired immediately
-   * with the current state, then on every transition. Multiple listeners are
-   * supported. Returns an unsubscribe function.
-   *
-   * @example
-   * ```typescript
-   * const unsub = iii.addConnectionStateListener((state) => {
-   *   console.log('connection state:', state)
-   * })
-   *
-   * // Later, stop receiving updates
-   * unsub()
-   * ```
-   */
-  addConnectionStateListener(handler: (state: IIIConnectionState) => void): () => void;
-}
-/**
- * Handle returned by {@link ISdk.registerTrigger}. Use `unregister()` to
- * remove the trigger from the engine.
- */
-type Trigger = {
-  /** Removes this trigger from the engine. */unregister(): void;
-};
-/**
- * Handle returned by {@link ISdk.registerFunction}. Contains the function's
- * `id` and an `unregister()` method.
- */
-type FunctionRef = {
-  /** The unique function identifier. */id: string; /** Removes this function from the engine. */
-  unregister: () => void;
-};
-/**
- * Typed handle returned by {@link ISdk.registerTriggerType}.
- *
- * Provides convenience methods to register triggers and functions scoped
- * to this trigger type, so callers don't need to repeat the `type` field.
- *
- * @typeParam TConfig - Trigger-specific configuration type.
- *
- * @example
- * ```typescript
- * type CronConfig = { expression: string }
- *
- * const cron = iii.registerTriggerType<CronConfig>(
- *   { id: 'cron', description: 'Fires on a cron schedule' },
- *   cronHandler,
- * )
- *
- * // Register a trigger -- type is inferred as CronConfig
- * cron.registerTrigger('my::fn', { expression: '0 *\/5 * * * * *' })
- *
- * // Register a function and bind a trigger in one call
- * cron.registerFunction(
- *   'my::fn',
- *   async (data) => { return { ok: true } },
- *   { expression: '0 *\/5 * * * * *' },
- * )
- * ```
- */
-type TriggerTypeRef<TConfig = unknown> = {
-  /** The trigger type identifier. */id: string;
-  /**
-   * Register a trigger bound to this trigger type.
-   *
-   * @param functionId - The function to invoke when the trigger fires.
-   * @param config - Trigger-specific configuration.
-   * @returns A {@link Trigger} handle with an `unregister()` method.
-   */
-  registerTrigger(functionId: string, config: TConfig): Trigger;
-  /**
-   * Register a function and immediately bind it to this trigger type.
-   *
-   * @param functionId - Unique function identifier.
-   * @param handler - Local function handler.
-   * @param config - Trigger-specific configuration.
-   * @returns A {@link FunctionRef} handle.
-   */
-  registerFunction(functionId: string, handler: RemoteFunctionHandler, config: TConfig): FunctionRef;
-  /**
-   * Unregister this trigger type from the engine.
-   */
-  unregister(): void;
-};
-/**
- * A streaming channel pair for worker-to-worker data transfer. Created via
- * {@link ISdk.createChannel}.
- */
-type Channel = {
-  /** Writer end of the channel. */writer: ChannelWriter; /** Reader end of the channel. */
-  reader: ChannelReader; /** Serializable reference to the writer (can be sent to other workers). */
-  writerRef: StreamChannelRef; /** Serializable reference to the reader (can be sent to other workers). */
-  readerRef: StreamChannelRef;
-};
-/**
- * Incoming HTTP request received by a function registered with an HTTP trigger.
- *
- * @typeParam TBody - Type of the parsed request body.
- */
-type ApiRequest<TBody = unknown> = {
-  path_params: Record<string, string>;
-  query_params: Record<string, string | string[]>;
-  body: TBody;
-  headers: Record<string, string | string[]>;
-  method: string;
-};
-/**
- * Structured API response returned from HTTP function handlers.
- *
- * @typeParam TStatus - HTTP status code literal type.
- * @typeParam TBody - Type of the response body.
- *
- * @example
- * ```typescript
- * const response: ApiResponse = {
- *   status_code: 200,
- *   headers: { 'content-type': 'application/json' },
- *   body: { message: 'ok' },
- * }
- * ```
- */
-type ApiResponse<TStatus extends number = number, TBody = string | Record<string, unknown>> = {
-  /** HTTP status code. */status_code: TStatus; /** Response headers. */
-  headers?: Record<string, string>; /** Response body. */
-  body?: TBody;
-};
-//#endregion
 //#region src/iii.d.ts
 /**
  * Configuration options passed to {@link registerWorker}.

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/iii-types.ts","../src/channels.ts","../src/iii-constants.ts","../src/triggers.ts","../src/types.ts","../src/iii.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/iii.ts"],"mappings":";;;;;;;;;;;;AAovBA;;KA9rBY,WAAA;EA4sBiB,4EA1sB3B,mBAAA;EAqsBkB;;;;;EA/rBlB,kBAAA,GAAqB,OAAA,CAAQ,qBAAA,GAosBF;EAlsB3B,OAAA,GAAU,MAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;cAorBC,aAAA;;;;;;;;;;IASO,KAAA;EAAA,MAAkB,eAAA;;;;;uBAK1B,eAAA;AAAA;;;;;;;;;;;;;;;;cAkBC,cAAA,GAAkB,OAAA,UAAiB,OAAA,GAAU,WAAA,KAAc,IAAA"}