@worker-protocol/schemas 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,671 @@
+import * as z from "zod";
+/**
+ * The Zod objects that generate `schemas/`.
+ *
+ * Nothing here carries behaviour of its own. Every constraint below encodes a rule that
+ * `spec/` already states, and each one cites the rule id it encodes so that a conformance
+ * report can name the rule rather than the file. Where `spec/` has not decided something, the
+ * object here is deliberately permissive and says so — a schema that overstates is worse than
+ * one that admits a hole, because the schema is the normative artifact and prose defers to it.
+ */
+/**
+ * The base every schema's `$id` is built on — and NO HOME HAS BEEN CHOSEN.
+ *
+ * `null` means each `$id` is the bare file name, which identifies a schema within this set and
+ * commits the project to no domain. Edition 0.1 is published and these packages are at 0.1.0, so
+ * the old justification — that nothing was published — has expired; the choice stands on what is
+ * left of it, which is that no home has been chosen and nothing consumes these by URL.
+ *
+ * A `$id` identifies; it does not have to resolve. Validation works whether or not anything is
+ * ever served at it, and relative `$ref`s between these schemas resolve against the document's
+ * own location exactly as they would against an absolute base.
+ *
+ * When a home is chosen, set this to something of the shape
+ * `https://<host>/worker-protocol/schemas` — namespaced under a path rather than hung off a
+ * domain root, so that a later move changes one segment and not the shape of every identifier.
+ * That is the only edit required: the host would then appear in each generated file on its own
+ * `$id` line and nowhere else, because every cross-schema `$ref` stays relative.
+ */
+export declare const SCHEMA_ID_BASE: string | null;
+/**
+ * DESC-23 — the edition of worker-protocol these schemas encode.
+ *
+ * It is not this package's version and cannot be read off it. A package version is SemVer and
+ * describes the package; an edition is `MAJOR.MINOR` and describes the protocol, and the two move
+ * for different reasons — a Zod major, a type made more precise, a build fixed, none of which is a
+ * change to anything a Worker sends. `packages/README.md` carries that argument, including why the
+ * two numbers agreeing today is a coincidence rather than a rule.
+ */
+export declare const EDITION = "0.1";
+/** The `$id` of one generated schema. A registry id is also its file name, plus `.json`. */
+export declare const schemaId: (name: string) => string;
+/**
+ * The registry the generator walks. A registry id becomes three things: the generated file name,
+ * the `$ref` other schemas point at — relative, so `capability-entry.json` and not a URL — and,
+ * once rewritten through `schemaId`, that file's own absolute `$id`.
+ */
+export declare const registry: z.core.$ZodRegistry<{
+    id: string;
+}, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+/**
+ * DESC-8 — the closed enumeration of Capability names this edition defines. Normative, and the
+ * list a verifier checks an undotted name against. `spec/README.md`'s table is a reading aid.
+ */
+export declare const capabilityName: z.ZodEnum<{
+    actions: "actions";
+    activity: "activity";
+    alerts: "alerts";
+    events: "events";
+    health: "health";
+    metrics: "metrics";
+    nudges: "nudges";
+    tasks: "tasks";
+}>;
+/**
+ * DESC-14 — a name containing a `.` is the Worker's own and is never defined by this
+ * specification. The pattern asserts only what DESC-14 asserts: at least one dot, and no dot at
+ * either end. naming.md answers the rest of the syntax by adding nothing to it: nobody compares one
+ * Worker's vendor Capability against another's, so there is no collision for a longer name to
+ * prevent.
+ */
+export declare const vendorCapabilityName: z.ZodString;
+/**
+ * NAME-7 — a name this protocol expects one party to match against a name that came from somewhere
+ * else: a Task type, a Skill, an event type.
+ *
+ * The pattern is at least three dot-separated labels — two or more for the DNS name in reverse
+ * label order, one or more for the local part — each a DNS label of lowercase letters, digits and
+ * hyphens, never starting or ending with a hyphen.
+ *
+ * Lowercase is asserted rather than left to taste, and it is the one part of this that is load-
+ * bearing rather than conventional. DNS is case-insensitive, so `Example.com` and `example.com`
+ * are one domain; NAME-1 compares names byte for byte, so `com.Example.x` and `com.example.x`
+ * would be two names for one thing. One spelling closes a trap the two rules open between them.
+ *
+ * NAME-8 — that the domain is one the minting team controls — has no schema witness and cannot
+ * have one. Nothing verifies domain ownership, which is why it recommends rather than binds.
+ */
+export declare const qualifiedName: z.ZodString;
+/**
+ * DESC-12 — an address is an absolute `https` URL, or a relative reference resolved against the
+ * URL the Descriptor was read from.
+ *
+ * The pattern is the load-bearing part: `format` is an annotation in Draft 2020-12 unless a
+ * validator opts into format-assertion, so a schema that relied on `format: "uri-reference"`
+ * alone would assert nothing. This admits a string that either begins `https://` or carries no
+ * scheme at all, which is exactly the two cases DESC-12 names.
+ */
+export declare const address: z.ZodString;
+/**
+ * DESC-22 — what a Worker declares about one Capability it implements.
+ *
+ * Loose on purpose, and the reason has changed since it was written. Every Capability file now
+ * defines its extension — `healthEntry`, `metricsEntry`, `actionsEntry`, `alertsEntry`,
+ * `activityEntry`, `nudgesEntry`, `tasksEntry`, `eventsEntry` — so this is no longer holding a door
+ * open for something unwritten.
+ * What keeps it loose is that `descriptor.json` still holds its entries as a record of THIS shape
+ * rather than binding each reserved name to its own, so closing it here would refuse every
+ * conformant Descriptor. Tightening that is a breaking change to the normative artifact and is
+ * listed in descriptor.md as the next edition's.
+ */
+export declare const capabilityEntry: z.ZodObject<{
+    version: z.ZodNumber;
+    address: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/**
+ * HLTH-2 — the three values a health status takes, and the only three.
+ *
+ * `degraded` is the one that earns its place: `healthy` and `unhealthy` alone would force a Worker
+ * that works with one dependency down to lie in one direction or the other.
+ */
+export declare const healthStatus: z.ZodEnum<{
+    degraded: "degraded";
+    healthy: "healthy";
+    unhealthy: "unhealthy";
+}>;
+/**
+ * HLTH-2 — one named check.
+ *
+ * Loose on purpose: health.md records as open what a check carries beyond its status and detail —
+ * an observed value, a unit, a threshold — and closing this would answer that by accident.
+ */
+export declare const healthCheck: z.ZodObject<{
+    status: z.ZodEnum<{
+        degraded: "degraded";
+        healthy: "healthy";
+        unhealthy: "unhealthy";
+    }>;
+    detail: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/**
+ * HLTH-2 — the whole answer.
+ *
+ * Closed, unlike a check: HLTH-2 enumerates the envelope exhaustively and no open question asks
+ * for a third member. The check object inside is where the open question lives.
+ *
+ * `checks` is required and may be empty. A Worker with no dependency worth reporting answers `{}`
+ * rather than omitting the member, so that every reader parses one shape.
+ */
+export declare const health: z.ZodObject<{
+    status: z.ZodEnum<{
+        degraded: "degraded";
+        healthy: "healthy";
+        unhealthy: "unhealthy";
+    }>;
+    checks: z.ZodRecord<z.ZodString, z.ZodObject<{
+        status: z.ZodEnum<{
+            degraded: "degraded";
+            healthy: "healthy";
+            unhealthy: "unhealthy";
+        }>;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$strict>;
+/**
+ * HLTH-1 — the `health` Capability entry, which requires the address the shared entry leaves
+ * optional. This is the extension DESC-22 promises each Capability's own file will define, and it
+ * is the first one.
+ */
+export declare const healthEntry: z.ZodObject<{
+    version: z.ZodNumber;
+    address: z.ZodString;
+}, z.core.$loose>;
+/**
+ * DESC-1, DESC-2, DESC-6, DESC-22, DESC-23 — the document every Worker serves.
+ *
+ * Closed on purpose: the rules above enumerate what a Descriptor carries, and a new top-level
+ * member is what an edition is for (DESC-23). A Worker extends its entries, not its Descriptor.
+ *
+ * `strictObject`, not `object`, so that the Zod objects other packages consume and the JSON
+ * Schema generated from them agree about the same document. Zod's default object STRIPS an
+ * unknown key while the generated `additionalProperties: false` REJECTS it — a TypeScript
+ * consumer and a Python one would otherwise reach opposite verdicts on one Descriptor.
+ */
+/**
+ * TASK-31 — what a Worker declares about one Skill, which today is nothing.
+ *
+ * Empty and strict on purpose. A Skill carries no declaration yet, and the shape for *nothing yet*
+ * is the one an optional member can join without invalidating a document already written — which
+ * NAME-5 calls compatible. A list of names could only have grown by becoming this, and becoming
+ * this later would have cost every Worker that declared a Skill a rewrite.
+ */
+export declare const skillDeclaration: z.ZodObject<{
+    payload: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    produces: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+}, z.core.$strict>;
+export declare const descriptor: z.ZodObject<{
+    id: z.ZodString;
+    edition: z.ZodString;
+    skills: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        payload: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+        produces: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    }, z.core.$strict>>>;
+    capabilities: z.ZodRecord<z.ZodUnion<readonly [z.ZodEnum<{
+        actions: "actions";
+        activity: "activity";
+        alerts: "alerts";
+        events: "events";
+        health: "health";
+        metrics: "metrics";
+        nudges: "nudges";
+        tasks: "tasks";
+    }>, z.ZodString]>, z.ZodObject<{
+        version: z.ZodNumber;
+        address: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$strict>;
+/**
+ * ENDP-25 — the closed code enumeration, split by the class each code carries.
+ *
+ * Every code names a condition some rule in `spec/` already states; none was invented to fill a
+ * gap. endpoints.md holds the other half of ENDP-26 — which status each code is answered with —
+ * because a status code is not in the body and no schema can assert it.
+ */
+export declare const rejectCodes: readonly ["malformed_request", "invalid_parameter", "unknown_filter", "unsupported_version", "idempotency_key_required", "unauthenticated", "forbidden", "not_found", "conflict", "idempotency_key_reused", "unprocessable_content", "schema_mismatch"];
+export declare const retryCodes: readonly ["request_timeout", "rate_limited", "internal_error", "unavailable", "upstream_error", "upstream_timeout"];
+/**
+ * ENDP-25, ENDP-26 — the envelope every response that is not a success carries.
+ *
+ * A union of two branches rather than one object with two independent fields, because ENDP-26
+ * says a code carries its class. Written as one object, `not_found` with a class of `retry` would
+ * validate cleanly and defeat the thing the class exists for. Written this way, the constraint
+ * holds in the Zod object and in the generated JSON alike, with no rule stated in only one of
+ * them.
+ *
+ * Each branch is loose: endpoints.md records as open whether the envelope carries structured
+ * detail beyond these three, and closing it here would answer that question by accident, in the
+ * artifact prose defers to.
+ */
+export declare const error: z.ZodUnion<readonly [z.ZodObject<{
+    code: z.ZodEnum<{
+        conflict: "conflict";
+        forbidden: "forbidden";
+        idempotency_key_required: "idempotency_key_required";
+        idempotency_key_reused: "idempotency_key_reused";
+        invalid_parameter: "invalid_parameter";
+        malformed_request: "malformed_request";
+        not_found: "not_found";
+        schema_mismatch: "schema_mismatch";
+        unauthenticated: "unauthenticated";
+        unknown_filter: "unknown_filter";
+        unprocessable_content: "unprocessable_content";
+        unsupported_version: "unsupported_version";
+    }>;
+    message: z.ZodString;
+    class: z.ZodLiteral<"reject">;
+}, z.core.$loose>, z.ZodObject<{
+    code: z.ZodEnum<{
+        internal_error: "internal_error";
+        rate_limited: "rate_limited";
+        request_timeout: "request_timeout";
+        unavailable: "unavailable";
+        upstream_error: "upstream_error";
+        upstream_timeout: "upstream_timeout";
+    }>;
+    message: z.ZodString;
+    class: z.ZodLiteral<"retry">;
+}, z.core.$loose>]>;
+/**
+ * ENDP-20, ENDP-21 — the envelope every surface that answers a list answers it in.
+ *
+ * Closed, unlike the error envelope, because ENDP-20 enumerates the envelope exhaustively and
+ * no open question asks for more. A surface that needs a third member is asking for a change to
+ * ENDP-20, which is a thing the register can see.
+ */
+export declare const page: z.ZodObject<{
+    items: z.ZodArray<z.ZodUnknown>;
+    nextCursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * MET-3 — the five periods a metric may accumulate over, and the only five.
+ *
+ * Closed because a console renders a period selector from what a metric declares, and an arbitrary
+ * duration would make that a free-text box. It is also where accumulation stops being a time
+ * series, which is the distinction this Capability rests on.
+ */
+export declare const metricGranularity: z.ZodEnum<{
+    day: "day";
+    hour: "hour";
+    month: "month";
+    week: "week";
+    year: "year";
+}>;
+/**
+ * MET-4 — one dimension a metric is broken down by, held under its name.
+ *
+ * `values` absent is the free case and is not the same as an empty list, which is why the minimum
+ * is 1: a dimension that declared no possible value could never be filtered to anything, and
+ * MET-17 would answer `400` for every value a caller sent.
+ *
+ * Declaring the set buys two different things, which is why metrics.md spends two rules on it:
+ * MET-17 refuses a value outside it, and MET-19 grants the dimension the right to be broken down
+ * by — a free dimension is filtered and never grouped, because nothing would bound the answer.
+ */
+/**
+ * MET-5, MET-16 — the characters a dimension name may use: what a query parameter needs, and no
+ * more. Shared between the declaration, the bucket and the `by` parameter so the three agree.
+ */
+export declare const DIMENSION_NAME: RegExp;
+export declare const metricDimension: z.ZodObject<{
+    values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+/**
+ * MET-21, MET-3, MET-4 — what a Worker declares about one metric.
+ *
+ * Closed: MET-3 and MET-4 enumerate the declaration, and no open question in metrics.md asks for
+ * another member of it. A member added later is what an edition is for, which is DESC-23.
+ *
+ * `dimensions` is required and may be empty, for the reason `checks` is in `health`: one shape for
+ * every reader, rather than a member whose absence and whose emptiness say the same thing.
+ */
+export declare const metricDeclaration: z.ZodObject<{
+    unit: z.ZodString;
+    additive: z.ZodBoolean;
+    granularities: z.ZodArray<z.ZodEnum<{
+        day: "day";
+        hour: "hour";
+        month: "month";
+        week: "week";
+        year: "year";
+    }>>;
+    dimensions: z.ZodRecord<z.ZodString, z.ZodObject<{
+        values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * MET-6 — an IANA Time Zone Database name.
+ *
+ * The separator is written `[/]` rather than `\/` so the generated pattern carries no JavaScript
+ * escape. A regular expression literal cannot hold a bare `/` outside a character class, and `\/`
+ * is an escape ECMA-262 accepts and Java refuses outright — a runtime's fingerprint smuggled into
+ * the normative artifact, which is the same thing the generator strips a safe-integer bound for.
+ *
+ * The pattern refuses the common wrong answers — an offset like `-03:00`, an abbreviation like
+ * `ART` — and asserts nothing about whether the zone exists. No schema can check a name against
+ * a database that ships with the reader.
+ */
+export declare const timeZone: z.ZodString;
+/**
+ * MET-1, MET-21, MET-6 — the `metrics` Capability entry.
+ *
+ * The address is required, as HLTH-1 requires it, because this Capability is answered over HTTP.
+ */
+export declare const metricsEntry: z.ZodObject<{
+    version: z.ZodNumber;
+    address: z.ZodString;
+    timeZone: z.ZodString;
+    publishes: z.ZodRecord<z.ZodString, z.ZodObject<{
+        unit: z.ZodString;
+        additive: z.ZodBoolean;
+        granularities: z.ZodArray<z.ZodEnum<{
+            day: "day";
+            hour: "hour";
+            month: "month";
+            week: "week";
+            year: "year";
+        }>>;
+        dimensions: z.ZodRecord<z.ZodString, z.ZodObject<{
+            values: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$loose>;
+/**
+ * An RFC 3339 instant carrying an offset — MET-13, TASK-28 and ALRT-3 all take one.
+ *
+ * `format` is an annotation in Draft 2020-12 unless a validator opts into format-assertion, so the
+ * pattern is what binds. It admits a wrong date — the 31st of February — because a regular
+ * expression that ruled those out would be unreadable, and a Worker that emits one has a bug no
+ * schema was going to find.
+ */
+export declare const INSTANT: RegExp;
+/**
+ * MET-12, MET-13, MET-15, MET-19 — one bucket.
+ *
+ * Closed, and it carries no name, unit or granularity: MET-8 has the caller name the metric and,
+ * where there is a choice, the granularity, and MET-21 has it read the unit from the Descriptor
+ * before it calls. Repeating any of them here would be a second place for them to disagree.
+ *
+ * It carries no status and no judgment of any kind. metrics.md answers `how much` and stops: a
+ * Worker that decides one of its own numbers is wrong raises an Alert, and what is inside a
+ * Worker's settings is not a thing this surface has a view of.
+ */
+export declare const metricBucket: z.ZodObject<{
+    start: z.ZodString;
+    end: z.ZodString;
+    value: z.ZodNullable<z.ZodNumber>;
+    dimensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strict>;
+/**
+ * MET-14 — what a read answers: the shared page envelope with its items narrowed, which is the
+ * narrowing ENDP-20 says each surface's own schema performs.
+ */
+export declare const metricPage: z.ZodObject<{
+    nextCursor: z.ZodOptional<z.ZodString>;
+    items: z.ZodArray<z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodString;
+        value: z.ZodNullable<z.ZodNumber>;
+        dimensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * ACT-12 — the declaration ENDP-15 requires of an Action that takes an idempotency key.
+ *
+ * A union rather than one object with an optional member, on the same reasoning that makes `error`
+ * a union: written flat, `from: "input"` with no member named would validate cleanly and leave the
+ * Worker with nowhere to read the key from. The two branches make the half-set state unspellable.
+ */
+export declare const idempotencyDeclaration: z.ZodUnion<readonly [z.ZodObject<{
+    required: z.ZodBoolean;
+    from: z.ZodLiteral<"header">;
+    windowSeconds: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    required: z.ZodBoolean;
+    from: z.ZodLiteral<"input">;
+    member: z.ZodString;
+    windowSeconds: z.ZodNumber;
+}, z.core.$strict>]>;
+/**
+ * ACT-2, ACT-3, ACT-4 — what a Worker declares about one Action.
+ *
+ * Closed: these rules enumerate the declaration, and a member added later is what an edition is
+ * for. The schemas INSIDE it are the Worker's own and are not constrained here — this protocol has
+ * no data model, and an Action's input is exactly where that matters most.
+ */
+export declare const actionDeclaration: z.ZodObject<{
+    input: z.ZodObject<{}, z.core.$loose>;
+    result: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    completesWithinCall: z.ZodBoolean;
+    idempotency: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        required: z.ZodBoolean;
+        from: z.ZodLiteral<"header">;
+        windowSeconds: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        required: z.ZodBoolean;
+        from: z.ZodLiteral<"input">;
+        member: z.ZodString;
+        windowSeconds: z.ZodNumber;
+    }, z.core.$strict>]>>;
+    readAddress: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * ACT-16 — the `actions` Capability entry.
+ *
+ * The address is required, as HLTH-1 and MET-1 require it, because this Capability is answered
+ * over HTTP. One address for the Capability and a parameter naming the Action, which is the shape
+ * `metrics` already uses — actions.md argues the two alternatives down at length.
+ */
+export declare const actionsEntry: z.ZodObject<{
+    version: z.ZodNumber;
+    address: z.ZodString;
+    accepts: z.ZodRecord<z.ZodString, z.ZodObject<{
+        input: z.ZodObject<{}, z.core.$loose>;
+        result: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+        completesWithinCall: z.ZodBoolean;
+        idempotency: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            required: z.ZodBoolean;
+            from: z.ZodLiteral<"header">;
+            windowSeconds: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            required: z.ZodBoolean;
+            from: z.ZodLiteral<"input">;
+            member: z.ZodString;
+            windowSeconds: z.ZodNumber;
+        }, z.core.$strict>]>>;
+        readAddress: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$loose>;
+/**
+ * TASK-32 — one Task type a Worker raises.
+ *
+ * The Actions named here are the OWNER's own, declared in its `actions` entry: a Response is an
+ * Action posted into the owner, so the closed list is a list of names that entry holds.
+ */
+export declare const taskTypeDeclaration: z.ZodObject<{
+    payload: z.ZodObject<{}, z.core.$loose>;
+    answeredBy: z.ZodString;
+}, z.core.$strict>;
+/**
+ * TASK-27, TASK-32 — the `tasks` Capability entry.
+ *
+ * One address, and a read. The entry carried a second one a claim was posted to until the Claim
+ * lifecycle was withdrawn; `spec/tasks.md` holds the argument, and the short of it is that a lease
+ * over a unit of work is orchestration, which this specification names a non-goal.
+ *
+ * It carried a third thing until TASK-31 moved it: what the Worker ANSWERS, which is served at no
+ * address and is now `skills` on the Descriptor's root. What is left here is what the declared
+ * address actually answers instances of.
+ */
+export declare const tasksEntry: z.ZodObject<{
+    version: z.ZodNumber;
+    address: z.ZodString;
+    raises: z.ZodRecord<z.ZodString, z.ZodObject<{
+        payload: z.ZodObject<{}, z.core.$loose>;
+        answeredBy: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$loose>;
+/**
+ * TASK-28 — one Task on the wire.
+ *
+ * It carries no status and nothing anybody declared about it. A Task exists while its condition
+ * holds (TASK-15) and disappears when it stops, so there is no state for a reader to interpret;
+ * what a reader needs is what it is, what would answer it, and how long it has been true.
+ */
+export declare const task: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    payload: z.ZodUnknown;
+    since: z.ZodString;
+}, z.core.$strict>;
+/** TASK-5 — what a read answers: the shared page envelope with its items narrowed to Tasks. */
+export declare const taskPage: z.ZodObject<{
+    nextCursor: z.ZodOptional<z.ZodString>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        payload: z.ZodUnknown;
+        since: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * ALRT-4 — the two severities, and the only two.
+ *
+ * The contrast with `healthStatus` is the argument rather than an inconsistency. `degraded` earns
+ * a third value there because a Worker working with one dependency down has a real state with no
+ * honest spelling in two. Here the only decision an operator takes is whether to look now, and a
+ * third value would be a place to hedge rather than a state anybody needed to express.
+ */
+export declare const alertSeverity: z.ZodEnum<{
+    critical: "critical";
+    warning: "warning";
+}>;
+/**
+ * ALRT-3 — one Alert.
+ *
+ * It carries no status and nothing anybody declared about it, for the reason a Task does not: an
+ * Alert exists while its condition holds and ends when it stops (ALRT-5), so there is no state for
+ * a reader to interpret and no dismissal for anyone to record.
+ */
+export declare const alert: z.ZodObject<{
+    id: z.ZodString;
+    severity: z.ZodEnum<{
+        critical: "critical";
+        warning: "warning";
+    }>;
+    since: z.ZodString;
+    summary: z.ZodString;
+    actions: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/** ALRT-2 — what a read answers: the page envelope with its items narrowed to Alerts. */
+export declare const alertPage: z.ZodObject<{
+    nextCursor: z.ZodOptional<z.ZodString>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodEnum<{
+            critical: "critical";
+            warning: "warning";
+        }>;
+        since: z.ZodString;
+        summary: z.ZodString;
+        actions: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** NDG-2 — one nudge on the wire: a Task type, and nothing else. */
+export declare const nudge: z.ZodObject<{
+    type: z.ZodString;
+}, z.core.$strict>;
+/** NDG-1 — the `nudges` Capability entry. The address is required: this is answered over HTTP. */
+export declare const nudgesEntry: z.ZodObject<{
+    version: z.ZodNumber;
+    address: z.ZodString;
+}, z.core.$loose>;
+/** ALRT-1 — the `alerts` Capability entry. The address is required: this is answered over HTTP. */
+export declare const alertsEntry: z.ZodObject<{
+    version: z.ZodNumber;
+    address: z.ZodString;
+}, z.core.$loose>;
+/**
+ * ACTV-4 — the three states an activity may be in, and the only three.
+ *
+ * Three rather than Alerts' two, on health's argument rather than alerts': a Worker that will run
+ * something at midnight and a Worker with four hundred items queued are both `not running`, and one
+ * word for both would make an operator unable to tell `backing up` from `waiting for its time`.
+ */
+export declare const activityState: z.ZodEnum<{
+    pending: "pending";
+    running: "running";
+    scheduled: "scheduled";
+}>;
+/**
+ * ACTV-3 — one activity.
+ *
+ * No type and no payload, deliberately: a payload with no declared schema is JSON nobody outside
+ * the Worker can validate or render, which is the blob alerts.md argues a protocol must not offer.
+ * The summary is for a person; the state is what a program acts on.
+ */
+export declare const activity: z.ZodObject<{
+    id: z.ZodString;
+    state: z.ZodEnum<{
+        pending: "pending";
+        running: "running";
+        scheduled: "scheduled";
+    }>;
+    since: z.ZodString;
+    summary: z.ZodString;
+}, z.core.$strict>;
+/** ACTV-2 — what a read answers: the page envelope with its items narrowed to activities. */
+export declare const activityPage: z.ZodObject<{
+    nextCursor: z.ZodOptional<z.ZodString>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        state: z.ZodEnum<{
+            pending: "pending";
+            running: "running";
+            scheduled: "scheduled";
+        }>;
+        since: z.ZodString;
+        summary: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** ACTV-1 — the `activity` Capability entry. The address is required: this is answered over HTTP. */
+export declare const activityEntry: z.ZodObject<{
+    version: z.ZodNumber;
+    address: z.ZodString;
+}, z.core.$loose>;
+/**
+ * EVT-11 — where an event lands on the broker its entry declares.
+ *
+ * An object and not a string, because what a consumer needs in order to attach is not alike across
+ * brokers: a Kafka topic beside its bootstrap servers, an Event Hub inside a namespace, an SNS ARN
+ * with a region in it. One string would have made every consumer parse this Worker's own way of
+ * packing several facts into one, which is the work a catalog exists to remove.
+ *
+ * Open, and nothing here reads a key of it — the same move an Action's input already makes. What
+ * that costs is that two Workers on one broker may spell it differently; `spec/events.md` argues
+ * why a namespaced name would not have fixed it and convention is what does.
+ */
+export declare const eventDestination: z.ZodObject<{}, z.core.$loose>;
+/** EVT-12, EVT-11 — one event type a Worker publishes. */
+export declare const eventTypeDeclaration: z.ZodObject<{
+    data: z.ZodObject<{}, z.core.$loose>;
+    destination: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+}, z.core.$strict>;
+/**
+ * EVT-11, EVT-12, EVT-8 — the `events` Capability entry.
+ *
+ * The one entry with NO address, which is the single reason DESC-22 leaves the address optional in
+ * the shared entry at all. An event travels over a broker this protocol declines to name, and a
+ * Worker with no HTTP surface for it would otherwise have had to invent a URL that does not exist.
+ */
+export declare const eventsEntry: z.ZodObject<{
+    version: z.ZodNumber;
+    address: z.ZodOptional<z.ZodString>;
+    broker: z.ZodString;
+    protocolBinding: z.ZodString;
+    destination: z.ZodObject<{}, z.core.$loose>;
+    publishes: z.ZodRecord<z.ZodString, z.ZodObject<{
+        data: z.ZodObject<{}, z.core.$loose>;
+        destination: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    }, z.core.$strict>>;
+    republishWindowSeconds: z.ZodNumber;
+}, z.core.$loose>;