better-supabase 0.13.0 → 0.15.0

package/dist/blocks/queue/index.d.ts

@@ -0,0 +1,562 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, f as Result, t as AsyncResult } from "../../result-DZeA5KS6.js";
+import { t as StandardSchemaV1$1 } from "../../standard-DBV730sF.js";
+import { n as ExtraFields, r as FieldsOf } from "../../block-fields-BE7pInWZ.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { n as BlockOptions, r as BlockTemporalOptions } from "../../block-helpers-CRpAHrp_.js";
+import { n as SqlClient } from "../../executor-hGjrop3A.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DWZSJrwN.js";
+import { n as BlockHooks } from "../../block-hooks-DZN2w69m.js";
+import { A as DeadJobRow, B as sqlQueueProvider, C as RunSchedulesOptions, D as ScheduleInfo, E as ScheduleFilter, F as QueuePurgeArgs, I as QueueRpcClient, L as QueueStats, M as QueueMessageBody, N as QueueMessageRow, O as ScheduleOptions, P as QueueProvider, R as TransportQueueProviderOptions, S as RetryDeadOptions, T as ScheduleDefinitions, V as transportQueueProvider, _ as ListDeadOptions, a as DrainResult, b as QueueOptions, c as EnqueueOnceOptions, d as EnsureSchedulesOptions, f as EnsureSchedulesResult, g as JobHandler, h as JobContext, i as DrainOptions, j as DueSchedule, k as WorkOptions, l as EnqueueOnceResult, m as Job, n as DeadJob, o as DrainRouteOptions, p as FailOptions, r as DrainMonitor, s as DrainRouteResult, t as ClaimOptions, u as EnqueueOptions, v as PurgeJobsOptions, w as ScheduleDefinition, x as QueueSchemas, y as Queue, z as pgmqPublicBackend } from "../../types-SFRomQF7.js";
+import { a as ProblemFormat, t as BlockProblemOptions } from "../../problem-DNwN8iGz.js";
+import { Xt as BlockSchedule, c as BlockOf } from "../../define-block-BVcLQ3DF.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/blocks/queue/cron.d.ts
+/**
+ * Throws a `TypeError` unless `expression` is a schedule `nextCronRun`
+ * understands: five cron fields, a macro such as `@daily`, or an interval such
+ * as `30 seconds`.
+ */
+export declare function assertCron(expression: string): void;
+/**
+ * The first run of `expression` after `after`, in `timeZone`.
+ *
+ * Accepts five cron fields (lists, ranges and steps; a restricted day of month
+ * and day of week match either, as in cron), the macros `@hourly`, `@daily`,
+ * `@weekly`, `@monthly` and `@yearly`, and intervals such as `30 seconds`, `5
+ * minutes` or `2 hours`, counted from `after`. A local time that a DST change
+ * skips runs at the same offset after the gap.
+ */
+export declare function nextCronRun(expression: string, timeZone: string, after: Temporal.Instant): Temporal.Instant;
+//#endregion
+//#region src/blocks/queue/block-schedules.d.ts
+/** The queue every block timer enqueues on. */
+export declare const BLOCK_TICKS_QUEUE = "block_ticks";
+/** The schedule name prefix of the block timers, for `ensureSchedules`. */
+export declare const BLOCK_SCHEDULE_PREFIX = "block:";
+/** The payload of a `block_ticks` job: which block timer fired. */
+interface BlockTick {
+  readonly block: string;
+  readonly name: string;
+}
+/** The `block_ticks` queue's payload schema, for `createQueue({ queues })`. */
+export declare const blockTickSchema: StandardSchemaV1<BlockTick>;
+/** A block as `blockSchedules` reads it: a manifest, or `createBlocks`'s list. */
+interface ScheduledBlock {
+  readonly name: string;
+  readonly schedules?: readonly BlockSchedule[];
+}
+/** The definitions `blockSchedules` returns, on the `block_ticks` queue. */
+type BlockScheduleDefinition = ScheduleDefinition<{
+  readonly [BLOCK_TICKS_QUEUE]: typeof blockTickSchema;
+}, typeof BLOCK_TICKS_QUEUE>;
+/**
+ * The timers the installed blocks declare, as queue schedules named
+ * `block:<block>.<name>`: pass them to
+ * `jobs.ensureSchedules(blockSchedules(blocks), { prefix: BLOCK_SCHEDULE_PREFIX
+ * })` on deploy, so SLA deadlines, sequence waits, AI schedules and workflow
+ * schedules all run from the one scheduler.
+ */
+export declare function blockSchedules(blocks: readonly ScheduledBlock[]): readonly BlockScheduleDefinition[];
+/** What a block timer's handler returns; a failed `Result` retries the job. */
+type BlockTickRun = () => PromiseLike<Result<unknown>>;
+/**
+ * The `block_ticks` queue handler: runs the handler named `<block>.<name>`,
+ * such as `"sla.check": () => sla.check()`. A tick without a handler, or a
+ * failed run, throws so the queue retries it and the dead letter shows it.
+ */
+export declare function blockTickHandler(handlers: Readonly<Record<string, BlockTickRun>>): (payload: BlockTick) => Promise<void>;
+//#endregion
+//#region src/blocks/queue/dev.d.ts
+interface DevDrainOptions {
+  readonly url: string | URL;
+  readonly secret: string;
+  readonly every?: number;
+  readonly fetch?: typeof fetch;
+  readonly signal?: AbortSignal;
+  readonly onError?: (message: string) => void;
+}
+interface DevDrain {
+  tick(): Promise<void>;
+  stop(): void;
+}
+export declare function devDrainSecret(env: Record<string, string | undefined>, name?: string): string;
+export declare function devDrain(options: DevDrainOptions): DevDrain;
+//#endregion
+//#region src/blocks/queue/idempotency.d.ts
+/**
+ * Where `createIdempotency` stores keys: a transport, or a service SQL
+ * connection.
+ */
+type IdempotencySource = {
+  /**
+   * A service-role transport, such as `rpcTransport(adminClient, { schema:
+   * "api" })` over the wrappers `blocks.idempotency.api` writes.
+   */
+  readonly transport: BlockTransport;
+  readonly sql?: never;
+} | {
+  /** A service SQL connection: `postgres.admin` or `ctx.postgresAdmin`. */
+  readonly sql: SqlClient;
+  readonly transport?: never;
+};
+type IdempotencyOptions = IdempotencySource & IdempotencySettings;
+interface IdempotencySettings extends BlockProblemOptions, BlockTemporalOptions {
+  /**
+   * Separates keys of different callers, endpoints or tenants. Defaults to a
+   * hash of the caller's credentials (the `Authorization` header or the
+   * Supabase auth cookies), so one caller never replays another's response.
+   * Pass the verified user id to keep keys across token refreshes.
+   */
+  readonly scope?: string | ((request: Request) => string);
+  /** How long a completed response is replayed. Defaults to `24 hours`. */
+  readonly ttl?: number | string;
+  /** How long a running request holds the key. Defaults to `1 minute`. */
+  readonly lock?: number | string;
+  /**
+   * Answer 400 when the header is missing. Defaults to false (run without a
+   * key).
+   */
+  readonly required?: boolean;
+  /** Defaults to `Idempotency-Key`. */
+  readonly header?: string;
+  /**
+   * The schema the functions live in, over a transport. Defaults to
+   * `better_supabase`.
+   */
+  readonly schema?: string;
+  /** Error mappers that run before the built-in ones, over a transport. */
+  readonly mappers?: readonly ErrorMapper[];
+  /**
+   * `withBlockHooks` hooks around `begin`, `extend`, `complete`, `release` and
+   * `purge`.
+   */
+  readonly hooks?: BlockHooks<Idempotency>;
+  /** Receives the errors `after` hooks throw. */
+  readonly logger?: Logger;
+}
+type IdempotencyState = "started" | "replay" | "running" | "mismatch";
+interface Idempotency {
+  /**
+   * Runs `handler` at most once per key: retries with the same key and body get
+   * the stored response (with `Idempotency-Replayed: true`).
+   */
+  handle(request: Request, handler: (request: Request) => Promise<Response> | Response): Promise<Response>;
+  /** The lower-level protocol, for non-HTTP callers. */
+  begin(key: string, fingerprint: string, scope?: string): AsyncResult<{
+    state: IdempotencyState;
+    status: number | null;
+    body: unknown;
+    /** The token `complete` and `release` need, when `state` is `started`. */
+    holder: string | undefined;
+  }>;
+  /**
+   * Moves the lock of a running key `lock` further for `holder`. `false` once
+   * the lock ran out or another caller took the key over. `handle` calls it at
+   * half the lock while the handler runs.
+   */
+  extend(key: string, holder: string, scope?: string): AsyncResult<boolean>;
+  /**
+   * Stores the response for `holder`. `false` when the lock ran out and another
+   * caller took the key over, so the response was not stored.
+   */
+  complete(key: string, holder: string, status: number, body: unknown, scope?: string): AsyncResult<boolean>;
+  /** Forgets the key so it can be retried; `false` when `holder` lost it. */
+  release(key: string, holder: string, scope?: string): AsyncResult<boolean>;
+  /** Deletes expired keys (`purge_idempotency_keys`); returns how many. */
+  purge(): AsyncResult<number>;
+  /** A job handler that runs `purge`; schedule it hourly. */
+  purgeJob(): JobHandler<unknown>;
+}
+/**
+ * HTTP idempotency keys (IETF `Idempotency-Key` header) over the `idempotency`
+ * SQL module: a service SQL connection, or a service-role `rpcTransport` over
+ * the wrappers `blocks.idempotency.api` writes.
+ */
+export declare function createIdempotency(options: IdempotencyOptions): Idempotency;
+//#endregion
+//#region src/blocks/queue/webhook-inbox.d.ts
+interface WebhookInboxMessage<T = unknown, F extends object = Record<never, never>> {
+  readonly id: number;
+  readonly source: string;
+  readonly messageId: string;
+  readonly type: string | null;
+  readonly payload: T;
+  readonly headers: Readonly<Record<string, string>>;
+  /** 1 on the first attempt. */
+  readonly attempts: number;
+  /**
+   * The source's limit when the message was stored. A handler running with
+   * `attempts === maxAttempts` is on its last attempt: when it fails, the
+   * message is marked dead.
+   */
+  readonly maxAttempts: number;
+  readonly receivedAt: Temporal.Instant;
+  /** The tenant the message was stored for, or null. */
+  readonly tenant: string | null;
+  /** Progress an earlier attempt saved with `checkpoint`, `{}` at first. */
+  readonly progress: Readonly<Record<string, unknown>>;
+  /** The extra columns, keyed by database name. */
+  readonly fields: ExtraFields<F>;
+  /**
+   * Saves progress mid-processing (merged into `progress`), so a retry resumes
+   * there, such as a provider's page cursor. `false` when the lease was lost.
+   * Only while the handler runs.
+   */
+  checkpoint(fields: Readonly<Record<string, unknown>>): Promise<boolean>;
+}
+/**
+ * A verified event to store, from `verify` or from `store` for a provider SDK
+ * that verifies itself.
+ */
+interface WebhookInboxEvent<F extends object = Record<never, never>> {
+  /** The sender's message id; the inbox stores each one once. */
+  readonly id: string;
+  readonly payload: unknown;
+  /** Defaults to `typeOf(payload)`. */
+  readonly type?: string | null;
+  /** Defaults to `tenantOf(payload)`. */
+  readonly tenant?: string | null;
+  readonly headers?: Readonly<Record<string, string>>;
+  /** The extra columns of a new message; a duplicate keeps the stored ones. */
+  readonly fields?: Partial<F>;
+}
+interface WebhookInboxOptions<S extends StandardSchemaV1$1 | undefined = undefined> extends BlockOptions, BlockProblemOptions {
+  /** Name of the sender, e.g. `stripe` or `supabase-auth`. */
+  readonly source: string;
+  /**
+   * Standard Webhooks secrets; the signature is verified before storing. Leave
+   * out `secrets` and `verify` for a source that only `store` fills (a chat or
+   * provider SDK that verifies its own requests); `receive` then throws.
+   */
+  readonly secrets?: string | readonly string[];
+  /**
+   * Custom verification for senders that don't use Standard Webhooks. It may
+   * also return the event's tenant.
+   */
+  readonly verify?: (request: Request, body: string) => Promise<Result<{
+    id: string;
+    payload: unknown;
+    tenant?: string | null;
+  }>>;
+  /** Event type from the payload. Defaults to `payload.type`. */
+  readonly typeOf?: (payload: unknown) => string | null;
+  /**
+   * The tenant a payload belongs to, for per-tenant integrations. Defaults to
+   * none.
+   */
+  readonly tenantOf?: (payload: unknown) => string | null | undefined;
+  /** Headers kept with the message. Defaults to none. */
+  readonly keepHeaders?: readonly string[];
+  readonly worker?: string;
+  /**
+   * Attempts before a message of this source is marked dead, stored with each
+   * message as it arrives. Defaults to 8.
+   */
+  readonly maxAttempts?: number;
+  /**
+   * The largest body `receive` reads; a larger one gets 413 without being read
+   * to the end. Defaults to 1 MiB.
+   */
+  readonly maxBodyBytes?: number;
+  /**
+   * A Standard Schema for the message's extra columns
+   * (`blocks.webhook-inbox.options.extraColumns`), keyed by database name. It
+   * validates them on `store`, and types and parses them on `list` and on the
+   * messages `process` hands the handler.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around `store`, `list` and `purge`. */
+  readonly hooks?: NoInfer<BlockHooks<WebhookInbox<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+interface WebhookInboxProcessOptions {
+  /** Messages claimed at once. Defaults to 10. */
+  readonly batch?: number;
+  /**
+   * How long a claimed message stays with this worker. It is renewed when the
+   * message's turn in the batch comes and every half lease while the handler
+   * runs. Defaults to 300 seconds.
+   */
+  readonly lease?: number | string;
+  /**
+   * Stop claiming after this many ms, so a backlog can't outrun a serverless
+   * function's maximum duration; claimed messages still finish. Defaults to no
+   * limit.
+   */
+  readonly budgetMs?: number;
+}
+interface WebhookInboxListOptions {
+  readonly tenant: string;
+  /** Only this status: `pending`, `processing`, `processed` or `dead`. */
+  readonly status?: "pending" | "processing" | "processed" | "dead";
+  /** Defaults to 100, at most 1000. */
+  readonly limit?: number;
+}
+/** A stored message as `list` returns it. */
+interface WebhookInboxEntry<F extends object = Record<never, never>> {
+  readonly id: number;
+  readonly messageId: string;
+  readonly type: string | null;
+  readonly status: "pending" | "processing" | "processed" | "dead";
+  readonly attempts: number;
+  readonly maxAttempts: number;
+  readonly lastError: string | null;
+  readonly tenant: string | null;
+  readonly receivedAt: Temporal.Instant;
+  readonly processedAt: Temporal.Instant | null;
+  /** The extra columns, keyed by database name. */
+  readonly fields: ExtraFields<F>;
+}
+interface WebhookInboxPurgeOptions {
+  /**
+   * Defaults to `30 days`; `0` with `tenant` removes all of that tenant's
+   * processed messages.
+   */
+  readonly olderThan?: number | string;
+  readonly includeDead?: boolean;
+  readonly tenant?: string;
+  readonly batch?: number;
+  /**
+   * The schema the functions live in, over a transport. Defaults to
+   * `better_supabase`.
+   */
+  readonly schema?: string;
+}
+/**
+ * Deletes processed messages from the inbox (`purge_webhooks`) over a service
+ * SQL connection or a service-role transport; returns how many.
+ */
+export declare function purgeWebhookInbox(source: SqlClient | BlockTransport, options?: WebhookInboxPurgeOptions): AsyncResult<number>;
+interface WebhookInbox<F extends object = Record<never, never>> {
+  /**
+   * Verifies and stores a webhook; answers 202, or 200 for a duplicate
+   * delivery. Throws a `TypeError` when the inbox has neither `secrets` nor
+   * `verify`.
+   */
+  receive(request: Request): Promise<Response>;
+  /**
+   * Stores an event your code already verified (a provider SDK that verifies
+   * and parses in one call). `duplicate` when the id was stored before.
+   */
+  store(event: WebhookInboxEvent<F>): AsyncResult<{
+    id: number;
+    duplicate: boolean;
+  }>;
+  /**
+   * Processes stored messages until none are ready, or until `budgetMs` is
+   * spent. A message whose lease another claim took over is skipped, and its
+   * outcome is not counted. A message whose extra columns the `fields` schema
+   * rejects fails without reaching the handler. The signal aborts when the
+   * lease can't be renewed; the message is then neither completed nor failed by
+   * this worker.
+   */
+  process<T = unknown>(handler: (message: WebhookInboxMessage<T, F>, signal: AbortSignal) => unknown, options?: WebhookInboxProcessOptions): Promise<DrainResult>;
+  /** A tenant's messages of this source, newest first. */
+  list(options: WebhookInboxListOptions): AsyncResult<WebhookInboxEntry<F>[]>;
+  /**
+   * Deletes old processed (and, with `includeDead`, dead) messages of this
+   * source's table; returns how many.
+   */
+  purge(options?: WebhookInboxPurgeOptions): AsyncResult<number>;
+  /** A job handler that runs `purge`; schedule it nightly. */
+  purgeJob(options?: WebhookInboxPurgeOptions): JobHandler<unknown>;
+}
+/**
+ * Store-then-process webhooks: acknowledge fast, process with retries, never
+ * twice. Pass a service transport, `sqlTransport(postgres.admin)`: the inbox
+ * functions are granted to the service role only.
+ */
+export declare function createWebhookInbox<S extends StandardSchemaV1$1 | undefined = undefined>(options: WebhookInboxOptions<S>): WebhookInbox<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/queue/lease.d.ts
+interface LeaseOptions {
+  /** How long the lease holds without an `extend`. Defaults to 60 seconds. */
+  readonly seconds?: number;
+  readonly scope?: string;
+  /**
+   * The schema the functions live in, over a transport. Defaults to
+   * `better_supabase`.
+   */
+  readonly schema?: string;
+}
+/** The held lease, passed to the `withLease` callback. */
+interface Lease {
+  readonly holder: string;
+  /** Moves the expiry; `false` once the lease was lost to another holder. */
+  extend(seconds?: number): AsyncResult<boolean>;
+}
+type LeaseOutcome<T> = {
+  readonly acquired: true;
+  readonly value: T;
+} | {
+  readonly acquired: false;
+};
+/**
+ * Runs `fn` while holding the lease on `key`, one holder at a time, and
+ * releases it afterwards, also when `fn` throws. `{ acquired: false }` while
+ * another holder has it. A lease that expires mid-run is taken by the next
+ * caller; call `lease.extend()` for long work. Takes a service SQL connection,
+ * or a service-role `rpcTransport` over the wrappers `blocks.idempotency.api`
+ * writes.
+ */
+export declare function withLease<T>(source: SqlClient | BlockTransport, key: string, fn: (lease: Lease) => Promise<T> | T, options?: LeaseOptions): AsyncResult<LeaseOutcome<T>>;
+//#endregion
+//#region src/blocks/queue/vercel-queue.d.ts
+/** What the backend reads of `@vercel/queue`'s message metadata. */
+interface VercelQueueMetadata {
+  readonly messageId: string;
+  readonly deliveryCount: number;
+  readonly createdAt: Date;
+  readonly expiresAt: Date;
+}
+/**
+ * The part of a `PollingQueueClient` from `@vercel/queue` the backend uses,
+ * typed structurally so the package stays an optional peer.
+ */
+interface VercelQueueClient {
+  send(topic: string, payload: unknown, options?: {
+    readonly idempotencyKey?: string;
+    readonly delaySeconds?: number;
+  }): PromiseLike<{
+    readonly messageId: string | null;
+  }>;
+  receive(topic: string, consumerGroup: string, handler: (message: unknown, metadata: VercelQueueMetadata) => PromiseLike<void> | void, options?: {
+    readonly limit?: number;
+    readonly visibilityTimeoutSeconds?: number;
+    readonly retry?: (error: unknown, metadata: VercelQueueMetadata) => {
+      readonly afterSeconds: number;
+    } | {
+      readonly acknowledge: true;
+    } | undefined;
+  }): PromiseLike<{
+    readonly ok: boolean;
+  }>;
+}
+interface VercelQueueProviderOptions {
+  /** The consumer group that reads the topics. Default `better-supabase`. */
+  readonly consumerGroup?: string;
+  /**
+   * Seconds a failed message waits before redelivery when `fail` gives no
+   * delay. Default 30.
+   */
+  readonly retryAfter?: number;
+  /**
+   * Milliseconds `read` waits for the rest of a batch after the first message.
+   * Default 25.
+   */
+  readonly settle?: number;
+}
+/**
+ * Stores jobs on Vercel Queues through a `PollingQueueClient`. Queue names are
+ * topic names. `read` holds each message open inside the client's `receive`
+ * handler (the client keeps the visibility timeout alive), `complete`
+ * acknowledges it and `fail` throws so the topic redelivers it after the retry
+ * delay. Vercel Queues has no dead letters, schedules or ids that fit a number,
+ * so ids are local handles, a message past `maxAttempts` is acknowledged and
+ * dropped, and schedules need the SQL backend.
+ */
+export declare function vercelQueueProvider(client: VercelQueueClient, options?: VercelQueueProviderOptions): QueueProvider;
+//#endregion
+//#region src/blocks/queue/queue.d.ts
+/** What `createQueue` stores jobs through. */
+type JobsSource = SqlClient | QueueRpcClient | BlockTransport | QueueProvider;
+/**
+ * Typed jobs on Supabase Queues (pgmq), over the `jobs` SQL module.
+ *
+ * Pass a service SQL connection (`postgres.admin`, `ctx.sql`) for the full
+ * feature set, a service-role `rpcTransport` over the wrappers
+ * `blocks.queue.api` writes for the same features over the Data API (or a
+ * service-role Supabase client with `schema` set to that schema), a
+ * service-role Supabase client to go through the `pgmq_public` RPCs, or any
+ * `QueueProvider`. Queue names are lowercase letters, digits and underscores.
+ */
+export declare function createQueue<const Q extends QueueSchemas>(options: QueueOptions<Q>): Queue<Q>;
+//#endregion
+//#region src/blocks/queue/rate-limit.d.ts
+/** One counted hit: whether it is allowed, and when to retry if not. */
+interface RateLimitDecision {
+  readonly allowed: boolean;
+  /** Hits left in the current window. */
+  readonly remaining: number;
+  /** Seconds until the window ends; 0 when allowed. */
+  readonly retryAfter: number;
+}
+/** A limit for one call, instead of the scope's rule from `set_rate_limit`. */
+interface RateLimitRule {
+  readonly max: number;
+  /** Seconds, or a Postgres interval such as `1 minute`. */
+  readonly period: number | string;
+}
+interface RateLimit {
+  /**
+   * Counts a hit of `key` (an API key, a public token, a tenant) against
+   * `scope`. The limit is the scope's rule (`set_rate_limit`) unless `rule`
+   * gives one.
+   */
+  check(scope: string, key: string, rule?: RateLimitRule): AsyncResult<RateLimitDecision>;
+  /**
+   * Deletes up to `batch` counters whose window ended (`purge_rate_limits`);
+   * returns how many.
+   */
+  purge(options?: {
+    readonly batch?: number;
+  }): AsyncResult<number>;
+  /** A job handler that runs `purge`; schedule it hourly. */
+  purgeJob(options?: {
+    readonly batch?: number;
+  }): JobHandler<unknown>;
+}
+/** Where `createRateLimit` keeps its counters: a transport or a SQL connection. */
+type RateLimitSource = {
+  /**
+   * A service-role transport, such as `rpcTransport(adminClient)`, over the
+   * `rate-limit` module's functions.
+   */
+  readonly transport: BlockTransport;
+  readonly sql?: never;
+} | {
+  /** A service SQL connection: `postgres.admin` or `ctx.postgresAdmin`. */
+  readonly sql: SqlClient;
+  readonly transport?: never;
+};
+interface RateLimitSettings extends BlockTemporalOptions {
+  /**
+   * The schema the functions live in, over a transport. Defaults to
+   * `better_supabase`.
+   */
+  readonly schema?: string;
+  /** Error mappers that run before the built-in ones. */
+  readonly mappers?: readonly ErrorMapper[];
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: BlockHooks<RateLimit>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+type RateLimitOptions = RateLimitSource & RateLimitSettings;
+/**
+ * Fixed-window limits for keys that aren't claims, over the `rate-limit`
+ * module's counters. Pass `sql`, a service SQL connection (`ctx.postgresAdmin`,
+ * `postgres.admin`), or `transport`, a service-role `BlockTransport` such as
+ * `rpcTransport(adminClient)`.
+ */
+export declare function createRateLimit(options: RateLimitOptions): RateLimit;
+/** A `problem+json` 429 with `Retry-After`, for a refused `check`. */
+export declare function rateLimited(decision: Pick<RateLimitDecision, "retryAfter">, options?: {
+  readonly instance?: string;
+  readonly detail?: string;
+  readonly problem?: ProblemFormat;
+}): Response;
+//#endregion
+//#region src/blocks/queue/manifest.d.ts
+/** The `jobs` block's manifest (ADR 0029). */
+export declare const queueBlock: BlockOf<"queue", typeof createQueue>;
+/** The `idempotency` block's manifest (ADR 0029). */
+export declare const idempotencyBlock: BlockOf<"idempotency", typeof createIdempotency>;
+/** The `rate-limit` block's manifest (ADR 0029). */
+export declare const rateLimitBlock: BlockOf<"rate-limit", typeof createRateLimit>;
+/** The `webhook-inbox` block's manifest (ADR 0029). */
+export declare const webhookInboxBlock: BlockOf<"webhook-inbox", typeof createWebhookInbox>;
+//#endregion
+export { type BlockScheduleDefinition, type BlockTick, type BlockTickRun, type BlockTransport, type ClaimOptions, type DeadJob, type DeadJobRow, type DevDrain, type DevDrainOptions, type DrainMonitor, type DrainOptions, type DrainResult, type DrainRouteOptions, type DrainRouteResult, type DueSchedule, type EnqueueOnceOptions, type EnqueueOnceResult, type EnqueueOptions, type EnsureSchedulesOptions, type EnsureSchedulesResult, type FailOptions, type Idempotency, type IdempotencyOptions, type IdempotencySettings, type IdempotencySource, type IdempotencyState, type Job, type JobContext, type JobHandler, type JobsSource, type Lease, type LeaseOptions, type LeaseOutcome, type ListDeadOptions, type PurgeJobsOptions, type Queue, type QueueMessageBody, type QueueMessageRow, type QueueOptions, type QueueProvider, type QueuePurgeArgs, type QueueRpcClient, type QueueSchemas, type QueueStats, type RateLimit, type RateLimitDecision, type RateLimitOptions, type RateLimitRule, type RateLimitSettings, type RateLimitSource, type RetryDeadOptions, type RunSchedulesOptions, type ScheduleDefinition, type ScheduleDefinitions, type ScheduleFilter, type ScheduleInfo, type ScheduleOptions, type ScheduledBlock, type SqlClient, type TransportQueueProviderOptions, type VercelQueueClient, type VercelQueueMetadata, type VercelQueueProviderOptions, type WebhookInbox, type WebhookInboxEntry, type WebhookInboxEvent, type WebhookInboxListOptions, type WebhookInboxMessage, type WebhookInboxOptions, type WebhookInboxProcessOptions, type WebhookInboxPurgeOptions, type WorkOptions, dbTransport, pgmqPublicBackend, rpcTransport, sqlQueueProvider, sqlTransport, transportQueueProvider };