ocel 0.0.1-alpha.0 → 0.0.1

package/dist/task/runs.d.ts

@@ -0,0 +1,74 @@
+import type { JsonObject } from "@bufbuild/protobuf";
+import { type Duration } from "../delivery/duration.js";
+import type { RunHandle, Task } from "./task.js";
+/** Where a run is in its life. */
+export type RunStatus = "DELAYED" | "QUEUED" | "EXECUTING" | "COMPLETED" | "FAILED" | "CANCELED" | "EXPIRED" | "TIMED_OUT";
+/** A run of a task, as the runs store records it. */
+export interface Run {
+    /** The run's id. */
+    id: string;
+    /** The name the task the run belongs to was declared under. */
+    task: string;
+    /** Where the run is in its life. */
+    status: RunStatus;
+    /** The payload it was triggered with. */
+    payload: unknown;
+    /** The output its `run` returned, once it completed. */
+    output: unknown;
+    /** The error that failed it, once it failed. */
+    error: string | undefined;
+    /** How many attempts were made. */
+    attempts: number;
+    /** The tags it was triggered with. */
+    tags: string[];
+    /** The metadata it was triggered with. */
+    metadata: JsonObject;
+    /** When it was triggered. */
+    createdAt: Date | undefined;
+    /** When it is or was due. */
+    dueAt: Date | undefined;
+    /** When its first attempt started. */
+    startedAt: Date | undefined;
+    /** When it ended. */
+    finishedAt: Date | undefined;
+    /** When it expires if it has not started. */
+    expiresAt: Date | undefined;
+}
+/** Which runs to list. */
+export interface ListRunsOptions {
+    /** Only the runs of this task, given as its handle or its declared name. */
+    task?: Task | string;
+    /** Only the runs in this status, or in any of these. */
+    status?: RunStatus | RunStatus[];
+    /** Only the runs carrying every one of these tags. */
+    tags?: string[];
+    /** The `nextCursor` of the previous page. */
+    cursor?: string;
+    /** The most runs on the page. */
+    limit?: number;
+}
+/** One page of runs. */
+export interface RunPage {
+    /** The runs on this page. */
+    runs: Run[];
+    /** Passed as `cursor` to read the next page; empty on the last one. */
+    nextCursor: string;
+}
+/** When a rescheduled run is due. */
+export interface RescheduleOptions {
+    /** How long from now the run is due, or the date it is due at. */
+    delay: Duration | Date;
+}
+/** Reads and acts on the runs of this app's tasks. */
+export declare const runs: {
+    /** The run with this id. */
+    retrieve(id: string): Promise<Run>;
+    /** One page of runs, newest first. */
+    list(options?: ListRunsOptions): Promise<RunPage>;
+    /** Stops the run from making another attempt; an attempt in progress sees its signal abort. */
+    cancel(id: string): Promise<Run>;
+    /** Starts a new run with the same payload and options, and answers its handle. */
+    replay(id: string): Promise<RunHandle>;
+    /** Moves a run that has not started to a new due time. */
+    reschedule(id: string, options: RescheduleOptions): Promise<Run>;
+};

package/dist/task/runs.js

@@ -0,0 +1,82 @@
+import { timestampDate } from "@bufbuild/protobuf/wkt";
+import { createClient } from "@connectrpc/connect";
+import { unprovisioned, unprovisionedPhase } from "../binding/unprovisioned.js";
+import { encodeDueAt } from "../delivery/duration.js";
+import { decodeJson } from "../delivery/payload.js";
+import { RunStatus as ProtoRunStatus, TaskService, } from "../gen/proto/app/task/v1/task_pb.js";
+import { createRuntimeTransport } from "../runtime/transport.js";
+const decodeTimestamp = (timestamp) => timestamp ? timestampDate(timestamp) : undefined;
+function decodeRun(run) {
+    if (!run)
+        throw new Error("the ocel runtime answered without a run");
+    return {
+        id: run.id,
+        task: run.task,
+        status: ProtoRunStatus[run.status],
+        payload: decodeJson(run.payload),
+        output: decodeJson(run.output),
+        error: run.error || undefined,
+        attempts: run.attempts,
+        tags: run.tags,
+        metadata: decodeJson(run.metadata) ?? {},
+        createdAt: decodeTimestamp(run.createdAt),
+        dueAt: decodeTimestamp(run.dueAt),
+        startedAt: decodeTimestamp(run.startedAt),
+        finishedAt: decodeTimestamp(run.finishedAt),
+        expiresAt: decodeTimestamp(run.expiresAt),
+    };
+}
+function encodeRunStatus(status) {
+    const value = ProtoRunStatus[status];
+    if (value === undefined) {
+        throw new Error(`"${status}" is not a run status`);
+    }
+    return value;
+}
+function createTaskClient(operation) {
+    if (unprovisionedPhase()) {
+        throw unprovisioned("runs", operation);
+    }
+    return createClient(TaskService, createRuntimeTransport());
+}
+/** Reads and acts on the runs of this app's tasks. */
+export const runs = {
+    /** The run with this id. */
+    async retrieve(id) {
+        const { run } = await createTaskClient("retrieve").retrieveRun({ id });
+        return decodeRun(run);
+    },
+    /** One page of runs, newest first. */
+    async list(options = {}) {
+        const client = createTaskClient("list");
+        const statuses = options.status === undefined
+            ? []
+            : (Array.isArray(options.status) ? options.status : [options.status]).map(encodeRunStatus);
+        const page = await client.listRuns({
+            task: typeof options.task === "string" ? options.task : (options.task?.name ?? ""),
+            statuses,
+            tags: options.tags ?? [],
+            cursor: options.cursor ?? "",
+            limit: options.limit ?? 0,
+        });
+        return { runs: page.runs.map(decodeRun), nextCursor: page.nextCursor };
+    },
+    /** Stops the run from making another attempt; an attempt in progress sees its signal abort. */
+    async cancel(id) {
+        const { run } = await createTaskClient("cancel").cancelRun({ id });
+        return decodeRun(run);
+    },
+    /** Starts a new run with the same payload and options, and answers its handle. */
+    async replay(id) {
+        const { id: replayed } = await createTaskClient("replay").replayRun({ id });
+        return { id: replayed };
+    },
+    /** Moves a run that has not started to a new due time. */
+    async reschedule(id, options) {
+        const { run } = await createTaskClient("reschedule").rescheduleRun({
+            id,
+            dueAt: encodeDueAt(options.delay),
+        });
+        return decodeRun(run);
+    },
+};

package/dist/task/task.d.ts

@@ -0,0 +1,117 @@
+import type { JsonObject } from "@bufbuild/protobuf";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import { type Duration } from "../delivery/duration.js";
+import { type Lane } from "../delivery/lane.js";
+import { type RetryOptions } from "../delivery/retry.js";
+import type { RunOptions } from "../worker/context.js";
+import type { Worker } from "../worker/worker.js";
+import type { TaskHooks } from "./hooks.js";
+/** How many runs a task takes at once, and how long it waits to fill them. */
+export interface BatchOptions {
+    /** The most runs one attempt receives. */
+    size: number;
+    /** How long a batch waits to fill before its runs are delivered. */
+    timeout?: Duration;
+}
+/** What a task's `run` receives for a payload, and returns. */
+export type RunFunction<TPayload, TOutput> = (payload: TPayload, options: RunOptions) => TOutput | Promise<TOutput>;
+/** How a task is declared. */
+export interface TaskOptions<TPayload, TOutput> extends TaskHooks<TPayload, TOutput> {
+    /** A Standard Schema every payload is validated against before `run` sees it. */
+    schema?: StandardSchemaV1;
+    /** Does the work of one run, or of one batch when `batch` is set. */
+    run: RunFunction<TPayload, TOutput>;
+    /** How a failed attempt is retried. */
+    retry?: RetryOptions;
+    /** The most runs of this task in progress at once. */
+    concurrency?: number;
+    /** The longest an attempt may take before the run ends as timed out. */
+    maxDuration?: Duration;
+    /** How long a run may wait to start before it expires. */
+    ttl?: Duration;
+    /** Runs one at a time per trigger `key`, in the order they were triggered. */
+    ordered?: boolean;
+    /** Delivers runs in batches; `run` then receives a list of payloads. */
+    batch?: BatchOptions;
+    /** The worker that serves this task; without one, the worker named `worker`. */
+    worker?: Worker;
+    /** A cron expression this task is triggered on. */
+    cron?: string;
+}
+/** How one trigger is run. */
+export interface TriggerOptions {
+    /** How long to wait before the run is due, or the date it is due at. */
+    delay?: Duration | Date;
+    /** How long the run may wait to start before it expires. */
+    ttl?: Duration;
+    /** A trigger repeating a key still remembered returns the run it started instead of a new one. */
+    idempotencyKey?: string;
+    /** How long `idempotencyKey` is remembered. */
+    idempotencyKeyTTL?: Duration;
+    /** Triggers sharing `key` within `delay` of each other fold into the first one's run, due `delay` after the last. */
+    debounce?: {
+        key: string;
+        delay: Duration;
+    };
+    /** Runs of an `ordered` task sharing this key run one at a time, in order. */
+    key?: string;
+    /** The lane the run waits in. */
+    lane?: Lane;
+    /** Lowers the task's own `retry.maxAttempts` for this run. */
+    maxAttempts?: number;
+    /** Tags `runs.list` can filter by. */
+    tags?: string[];
+    /** Values stored with the run. */
+    metadata?: JsonObject;
+}
+/** One item of a `batchTrigger`. */
+export interface BatchTriggerItem<TInput> {
+    /** The run's payload. */
+    payload: TInput;
+    /** How the run is triggered. */
+    options?: TriggerOptions;
+}
+/** A triggered run. */
+export interface RunHandle {
+    /** The run's id, which `runs` reads and acts on. */
+    id: string;
+}
+/** A declared task, and the handle its runs are triggered through. */
+export declare class Task<TInput = unknown, TOutput = unknown> {
+    /** The name this task was declared under. */
+    readonly name: string;
+    /** Type-only: the payload `trigger` takes and the output `run` returns. */
+    readonly types?: {
+        input: TInput;
+        output: TOutput;
+    };
+    private client;
+    constructor(name: string, options: TaskOptions<never, unknown>);
+    private ensureClient;
+    /** Starts a run of this task with `payload`. */
+    trigger(payload: TInput, options?: TriggerOptions): Promise<RunHandle>;
+    /** Starts one run per item, and answers their handles in the order of `items`. */
+    batchTrigger(items: BatchTriggerItem<TInput>[]): Promise<RunHandle[]>;
+}
+type SchemaOptions<TSchema extends StandardSchemaV1, TPayload, TOutput> = Omit<TaskOptions<TPayload, TOutput>, "schema"> & {
+    schema: TSchema;
+};
+/** Declares a task whose payloads `schema` validates, delivered in batches. */
+export declare function task<TSchema extends StandardSchemaV1, TOutput = undefined>(name: string, options: SchemaOptions<TSchema, StandardSchemaV1.InferOutput<TSchema>[], TOutput> & {
+    batch: BatchOptions;
+}): Task<StandardSchemaV1.InferInput<TSchema>, TOutput>;
+/** Declares a task whose payloads `schema` validates. */
+export declare function task<TSchema extends StandardSchemaV1, TOutput = undefined>(name: string, options: SchemaOptions<TSchema, StandardSchemaV1.InferOutput<TSchema>, TOutput> & {
+    batch?: undefined;
+}): Task<StandardSchemaV1.InferInput<TSchema>, TOutput>;
+/** Declares a task delivered in batches, typed by the list its `run` takes. */
+export declare function task<TPayload = unknown, TOutput = undefined>(name: string, options: TaskOptions<TPayload[], TOutput> & {
+    schema?: undefined;
+    batch: BatchOptions;
+}): Task<TPayload, TOutput>;
+/** Declares a task, typed by the payload its `run` takes. */
+export declare function task<TPayload = unknown, TOutput = undefined>(name: string, options: TaskOptions<TPayload, TOutput> & {
+    schema?: undefined;
+    batch?: undefined;
+}): Task<TPayload, TOutput>;
+export {};

package/dist/task/task.js

@@ -0,0 +1,109 @@
+import { createClient } from "@connectrpc/connect";
+import { refuseUnbound } from "../binding/binding.js";
+import { unprovisioned, unprovisionedPhase } from "../binding/unprovisioned.js";
+import { declarationSite } from "../declaration/callsite.js";
+import { defer } from "../declaration/defer.js";
+import { encodeDueAt, encodeDuration } from "../delivery/duration.js";
+import { encodeLane } from "../delivery/lane.js";
+import { encodePayload } from "../delivery/payload.js";
+import { encodeRetryPolicy } from "../delivery/retry.js";
+import { encodeJsonSchema } from "../delivery/schema.js";
+import { ResourceType } from "../gen/proto/app/resources/v1/resources_pb.js";
+import { TaskService } from "../gen/proto/app/task/v1/task_pb.js";
+import { rpc } from "../runtime/rpc.js";
+import { createRuntimeTransport } from "../runtime/transport.js";
+import { DEFAULT_WORKER, registerRun } from "../worker/registry.js";
+function encodeTriggerOptions(options = {}) {
+    return {
+        dueAt: encodeDueAt(options.delay),
+        ttl: encodeDuration(options.ttl),
+        idempotencyKey: options.idempotencyKey ?? "",
+        idempotencyKeyTtl: encodeDuration(options.idempotencyKeyTTL),
+        debounce: options.debounce && {
+            key: options.debounce.key,
+            delay: encodeDuration(options.debounce.delay),
+        },
+        key: options.key ?? "",
+        lane: encodeLane(options.lane),
+        maxAttempts: options.maxAttempts ?? 0,
+        tags: options.tags ?? [],
+        metadata: options.metadata && new TextEncoder().encode(JSON.stringify(options.metadata)),
+    };
+}
+/** A declared task, and the handle its runs are triggered through. */
+export class Task {
+    /** The name this task was declared under. */
+    name;
+    client;
+    constructor(name, options) {
+        this.name = name;
+        registerRun({
+            kind: "task",
+            topic: name,
+            name,
+            worker: options.worker?.name ?? DEFAULT_WORKER,
+            batch: options.batch !== undefined,
+            schema: options.schema,
+            run: options.run,
+            hooks: options,
+        });
+        if (process.env.OCEL_PHASE === "discovery") {
+            defer(rpc.resource.declare({
+                resource: { name, type: ResourceType.TASK },
+                config: {
+                    case: "task",
+                    value: {
+                        schema: encodeJsonSchema(options.schema),
+                        ordered: options.ordered ?? false,
+                        retry: encodeRetryPolicy(options.retry),
+                        concurrency: options.concurrency ?? 0,
+                        maxDuration: encodeDuration(options.maxDuration),
+                        ttl: encodeDuration(options.ttl),
+                        batch: options.batch && {
+                            size: options.batch.size,
+                            timeout: encodeDuration(options.batch.timeout),
+                        },
+                        worker: options.worker?.name ?? "",
+                        cron: options.cron ?? "",
+                    },
+                },
+                source: declarationSite(),
+            }));
+        }
+    }
+    ensureClient(operation) {
+        if (unprovisionedPhase()) {
+            throw unprovisioned(`task("${this.name}")`, operation);
+        }
+        const refusal = refuseUnbound(this.name, "task");
+        if (refusal) {
+            throw refusal;
+        }
+        return (this.client ??= createClient(TaskService, createRuntimeTransport()));
+    }
+    /** Starts a run of this task with `payload`. */
+    async trigger(payload, options) {
+        const client = this.ensureClient("trigger");
+        const { id } = await client.trigger({
+            task: this.name,
+            payload: encodePayload(payload),
+            options: encodeTriggerOptions(options),
+        });
+        return { id };
+    }
+    /** Starts one run per item, and answers their handles in the order of `items`. */
+    async batchTrigger(items) {
+        const client = this.ensureClient("batchTrigger");
+        const { ids } = await client.batchTrigger({
+            task: this.name,
+            items: items.map((item) => ({
+                payload: encodePayload(item.payload),
+                options: encodeTriggerOptions(item.options),
+            })),
+        });
+        return ids.map((id) => ({ id }));
+    }
+}
+export function task(name, options) {
+    return new Task(name, options);
+}

package/dist/topic/dead-letters.d.ts

@@ -0,0 +1,53 @@
+import type { Client } from "@connectrpc/connect";
+import type { TopicService } from "../gen/proto/app/topic/v1/topic_pb.js";
+/** A message a consumer gave up on after its last attempt failed. */
+export interface DeadLetter {
+    /** The execution that failed: the message as this consumer received it. */
+    execution: string;
+    /** The message's id. */
+    messageId: string;
+    /** When the message was sent. */
+    publishedAt: Date | undefined;
+    /** The message's payload. */
+    payload: unknown;
+    /** How many attempts were made. */
+    attempts: number;
+    /** The last attempt's error. */
+    error: string;
+    /** When the last attempt failed. */
+    failedAt: Date | undefined;
+}
+/** One page of dead letters. */
+export interface DeadLetterPage {
+    /** The dead letters on this page. */
+    deadLetters: DeadLetter[];
+    /** Passed as `cursor` to read the next page; empty on the last one. */
+    nextCursor: string;
+}
+/** Which page of dead letters to read. */
+export interface DeadLetterListOptions {
+    /** The `nextCursor` of the previous page. */
+    cursor?: string;
+    /** The most dead letters on the page. */
+    limit?: number;
+}
+interface TopicConnection {
+    client: Client<typeof TopicService>;
+    topic: string;
+}
+/** The dead letters of one consumer of a topic. */
+export declare class DeadLetters {
+    /** The consumer these dead letters belong to. */
+    readonly consumer: string;
+    private readonly connect;
+    constructor(consumer: string, connect: (operation: string) => TopicConnection);
+    /** One page of this consumer's dead letters. */
+    list(options?: DeadLetterListOptions): Promise<DeadLetterPage>;
+    /** Delivers the given executions again, or every dead letter; answers how many. */
+    redrive(executions?: string[]): Promise<number>;
+    /** Deletes the given executions, or every dead letter; answers how many. */
+    purge(executions?: string[]): Promise<number>;
+    /** How many dead letters this consumer has. */
+    count(): Promise<number>;
+}
+export {};

package/dist/topic/dead-letters.js

@@ -0,0 +1,62 @@
+import { timestampDate } from "@bufbuild/protobuf/wkt";
+import { decodeJson } from "../delivery/payload.js";
+function decodeDeadLetter(letter) {
+    return {
+        execution: letter.execution,
+        messageId: letter.message?.id ?? "",
+        publishedAt: letter.message?.publishedAt
+            ? timestampDate(letter.message.publishedAt)
+            : undefined,
+        payload: decodeJson(letter.payload),
+        attempts: letter.attempts,
+        error: letter.error,
+        failedAt: letter.failedAt ? timestampDate(letter.failedAt) : undefined,
+    };
+}
+/** The dead letters of one consumer of a topic. */
+export class DeadLetters {
+    /** The consumer these dead letters belong to. */
+    consumer;
+    connect;
+    constructor(consumer, connect) {
+        this.consumer = consumer;
+        this.connect = connect;
+    }
+    /** One page of this consumer's dead letters. */
+    async list(options = {}) {
+        const { client, topic } = this.connect("deadLetter.list");
+        const page = await client.listDeadLetters({
+            topic,
+            consumer: this.consumer,
+            cursor: options.cursor ?? "",
+            limit: options.limit ?? 0,
+        });
+        return { deadLetters: page.deadLetters.map(decodeDeadLetter), nextCursor: page.nextCursor };
+    }
+    /** Delivers the given executions again, or every dead letter; answers how many. */
+    async redrive(executions = []) {
+        const { client, topic } = this.connect("deadLetter.redrive");
+        const { redriven } = await client.redriveDeadLetters({
+            topic,
+            consumer: this.consumer,
+            executions,
+        });
+        return Number(redriven);
+    }
+    /** Deletes the given executions, or every dead letter; answers how many. */
+    async purge(executions = []) {
+        const { client, topic } = this.connect("deadLetter.purge");
+        const { purged } = await client.purgeDeadLetters({
+            topic,
+            consumer: this.consumer,
+            executions,
+        });
+        return Number(purged);
+    }
+    /** How many dead letters this consumer has. */
+    async count() {
+        const { client, topic } = this.connect("deadLetter.count");
+        const { count } = await client.countDeadLetters({ topic, consumer: this.consumer });
+        return Number(count);
+    }
+}

package/dist/topic/index.d.ts

@@ -0,0 +1,8 @@
+export { UnprovisionedResourceError } from "../binding/unprovisioned.js";
+export type { Duration } from "../delivery/duration.js";
+export type { Lane } from "../delivery/lane.js";
+export type { RetryOptions } from "../delivery/retry.js";
+export { AbortTaskRunError } from "../task/errors.js";
+export type { RunContext, RunOptions } from "../worker/context.js";
+export { type DeadLetter, type DeadLetterListOptions, type DeadLetterPage, DeadLetters, } from "./dead-letters.js";
+export { type BatchConsumerOptions, type Consumer, type ConsumerFunction, type ConsumerOptions, type SendOptions, Topic, type TopicOptions, topic, } from "./topic.js";

package/dist/topic/index.js

@@ -0,0 +1,4 @@
+export { UnprovisionedResourceError } from "../binding/unprovisioned.js";
+export { AbortTaskRunError } from "../task/errors.js";
+export { DeadLetters, } from "./dead-letters.js";
+export { Topic, topic, } from "./topic.js";

package/dist/topic/topic.d.ts

@@ -0,0 +1,85 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import { type Duration } from "../delivery/duration.js";
+import { type Lane } from "../delivery/lane.js";
+import { type RetryOptions } from "../delivery/retry.js";
+import type { RunOptions } from "../worker/context.js";
+import type { Worker } from "../worker/worker.js";
+import { DeadLetters } from "./dead-letters.js";
+/** How a topic is declared. */
+export interface TopicOptions<TSchema extends StandardSchemaV1 | undefined> {
+    /** A Standard Schema every consumer validates a payload against before it sees it. */
+    schema?: TSchema;
+    /** Delivers messages sharing a send `key` one at a time, in the order they were sent. */
+    ordered?: boolean;
+    /** How a consumer's failed attempt is retried, unless the consumer says otherwise. */
+    retry?: RetryOptions;
+}
+/** How one message is sent. */
+export interface SendOptions {
+    /** How long to wait before the message is delivered, or the date it is delivered at. */
+    delay?: Duration | Date;
+    /** A send repeating a key still remembered is delivered once. */
+    idempotencyKey?: string;
+    /** Messages of an `ordered` topic sharing this key are delivered one at a time, in order. */
+    key?: string;
+    /** The lane the message waits in. */
+    lane?: Lane;
+}
+/** How a consumer is declared. */
+export interface ConsumerOptions {
+    /** How a failed attempt is retried; without it, the topic's `retry`. */
+    retry?: RetryOptions;
+    /** The most messages this consumer serves at once. */
+    concurrency?: number;
+    /** The lanes this consumer reads; without them, every lane. */
+    lanes?: Lane[];
+    /** The longest an attempt may take before it counts as failed. */
+    maxDuration?: Duration;
+    /** The worker that serves this consumer; without one, the worker named `worker`. */
+    worker?: Worker;
+}
+/** How a batch consumer is declared. */
+export interface BatchConsumerOptions extends ConsumerOptions {
+    /** The most messages one attempt receives. */
+    batchSize: number;
+    /** How long a batch waits to fill before it is delivered. */
+    batchTimeout?: Duration;
+}
+/** What a consumer does with one message. */
+export type ConsumerFunction<TPayload> = (payload: TPayload, options: RunOptions) => unknown;
+/** A declared consumer of a topic. */
+export interface Consumer {
+    /** The name this consumer was declared under. */
+    readonly name: string;
+    /** The name of the topic it consumes. */
+    readonly topic: string;
+}
+/** A declared topic, and the handle its messages are sent through. */
+export declare class Topic<TInput = unknown, TOutput = TInput> {
+    /** The name this topic was declared under. */
+    readonly name: string;
+    /** Type-only: the payload `send` takes and the payload a consumer receives. */
+    readonly types?: {
+        input: TInput;
+        output: TOutput;
+    };
+    private readonly schema;
+    private client;
+    constructor(name: string, options: TopicOptions<StandardSchemaV1 | undefined>);
+    private ensureClient;
+    /** Sends `payload` to every consumer of this topic, and answers the message's id. */
+    send(payload: TInput, options?: SendOptions): Promise<string>;
+    private declareConsumer;
+    /** Declares a consumer that receives every message sent to this topic, one at a time. */
+    consumer(name: string, run: ConsumerFunction<TOutput>, options?: ConsumerOptions): Consumer;
+    /** Declares a consumer that receives the messages sent to this topic in batches. */
+    batchConsumer(name: string, run: ConsumerFunction<TOutput[]>, options: BatchConsumerOptions): Consumer;
+    /** The messages a consumer of this topic gave up on. */
+    deadLetter(consumer: string | Consumer): DeadLetters;
+}
+/** Declares a topic whose payloads `schema` validates. */
+export declare function topic<TSchema extends StandardSchemaV1>(name: string, options: TopicOptions<TSchema> & {
+    schema: TSchema;
+}): Topic<StandardSchemaV1.InferInput<TSchema>, StandardSchemaV1.InferOutput<TSchema>>;
+/** Declares a topic whose payloads are of type `TPayload`. */
+export declare function topic<TPayload = unknown>(name: string, options?: TopicOptions<undefined>): Topic<TPayload, TPayload>;