@fleetless/contracts 1.0.0

package/dist/config.d.ts

@@ -0,0 +1,862 @@
+import { z } from 'zod';
+/**
+ * What an exposed service *is*, in the developer's own words (§17).
+ *
+ * This is what `robot_describe` carries verbatim, so it is read by a model
+ * that has never seen this robot and cannot ask a follow-up question.
+ * `unit` and `range` already say what a number *is*; this says what it
+ * *means*.
+ *
+ * **It lives on the configuration rather than on the app, and that was a
+ * decision with a cost.** §17's own wording put the semantic descriptions in
+ * the MCP app; André moved them here on 2026-08-18 so that a description is
+ * written once per service and true for every app that reaches the robot,
+ * beside the other metadata. What is given up is real and should not be
+ * rediscovered as a bug: **two apps can no longer describe one service
+ * differently for two audiences.** §17 was reworded in the same wave rather
+ * than left contradicting this field.
+ *
+ * **`.optional()` and not `.nullable().default(null)`, deliberately.** The
+ * established shape in this file is a default — and every use of it has
+ * added an instance to a known contradiction: `.default()` publishes the
+ * field as **required** in the generated JSON Schema, because after parsing
+ * it is always present. That is recorded four times over in
+ * `scripts/export-schemas.ts`, whose fix (`io: 'input'`, applied per schema)
+ * is a judgement call across roughly sixty schemas plus a re-vendor and a
+ * re-pin in four repos. W7c's playbook said task 0 would do it; reading the
+ * measured blast radius — 90 artifacts, 436 deletions for the blanket
+ * version — said otherwise, at the start of a wave with five people blocked
+ * on this pin. So the field simply does not create a fifth instance:
+ * optional is optional in both modes, and *absent* is the single spelling of
+ * "not described". `.min(1)` keeps the empty string from becoming a second.
+ */
+export declare const serviceDescription: z.ZodOptional<z.ZodString>;
+/**
+ * One parameter's prose, for the same reader as `serviceDescription` and
+ * under the same rules. Shorter, because it describes one field of one call
+ * rather than the call itself.
+ */
+export declare const parameterDescription: z.ZodOptional<z.ZodString>;
+/** The ROS 2 primitive field types, spelled as ROS 2 spells them. */
+export declare const parameterType: z.ZodEnum<{
+    string: "string";
+    bool: "bool";
+    byte: "byte";
+    char: "char";
+    int8: "int8";
+    uint8: "uint8";
+    int16: "int16";
+    uint16: "uint16";
+    int32: "int32";
+    uint32: "uint32";
+    int64: "int64";
+    uint64: "uint64";
+    float32: "float32";
+    float64: "float64";
+    wstring: "wstring";
+}>;
+export type ParameterType = z.infer<typeof parameterType>;
+/**
+ * One parameter a caller may fill in a message template.
+ *
+ * `type` is required and **not derived from the template position**, even
+ * though introspection usually knows it. The reason is the robot that has
+ * never connected: there is nothing to derive there, and that is exactly
+ * where the editor has to help most.
+ *
+ * Which constraints exist depends on the type, and a constraint on the wrong
+ * type is refused rather than silently inert. Floats deliberately have no
+ * `enum`: equality on floating point is unreliable, so an enumerated float
+ * list is a trap that only shows up in operation.
+ *
+ * **A `default` and every `enum` entry must match `type`**, and that is
+ * decided here rather than in the cloud. Its sibling
+ * `constraint_not_allowed_for_type` was always here, and leaving one of a
+ * pair in zod and the other in the cloud is two policies for one decision.
+ * It needs nothing this schema does not have: a value and a declared type.
+ * `type_mismatch` — the declared type against the type at the template
+ * position — is the one that needs introspection, and it is the cloud's.
+ *
+ * There is no `required` field. A placeholder cannot be left unfilled, so
+ * "required" is exactly "has no `default`" — a second spelling of one fact
+ * is the defect this file has spent two waves removing.
+ */
+export declare const parameterSpec: z.ZodObject<{
+    type: z.ZodEnum<{
+        string: "string";
+        bool: "bool";
+        byte: "byte";
+        char: "char";
+        int8: "int8";
+        uint8: "uint8";
+        int16: "int16";
+        uint16: "uint16";
+        int32: "int32";
+        uint32: "uint32";
+        int64: "int64";
+        uint64: "uint64";
+        float32: "float32";
+        float64: "float64";
+        wstring: "wstring";
+    }>;
+    default: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+    min_value: z.ZodOptional<z.ZodNumber>;
+    max_value: z.ZodOptional<z.ZodNumber>;
+    enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    regex: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ParameterSpec = z.infer<typeof parameterSpec>;
+/** Parameters of one entry, keyed by name. At most 50. */
+export declare const parameterMap: z.ZodRecord<z.ZodString, z.ZodObject<{
+    type: z.ZodEnum<{
+        string: "string";
+        bool: "bool";
+        byte: "byte";
+        char: "char";
+        int8: "int8";
+        uint8: "uint8";
+        int16: "int16";
+        uint16: "uint16";
+        int32: "int32";
+        uint32: "uint32";
+        int64: "int64";
+        uint64: "uint64";
+        float32: "float32";
+        float64: "float64";
+        wstring: "wstring";
+    }>;
+    default: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+    min_value: z.ZodOptional<z.ZodNumber>;
+    max_value: z.ZodOptional<z.ZodNumber>;
+    enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    regex: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>>;
+/**
+ * Slugs no configured entry may take (spec §4.3), across **all five exposure
+ * sections at once** — slugs are one namespace, so a name reserved here is
+ * reserved everywhere.
+ *
+ * The first three are built-ins: the cloud or the bridge already publishes
+ * something under them, so a configured entry would be a second producer for
+ * one name. `history` is reserved for a different reason and is not a built-in
+ * — nothing publishes it. `GET /api/robots/:id/jobs/history` is a **literal
+ * sibling** of `GET /api/robots/:id/jobs/:slug`, so an action or service named
+ * `history` would have a job route no caller could ever reach. Reserving the
+ * name is the honest half of that: the alternative is a slug the format
+ * accepts and one route silently cannot address.
+ *
+ * **This constant is the only list.** The cloud's `validation.ts` builds its
+ * set from it and emits `reserved_slug`; `config-store.ts` reads it for the
+ * rename target; the console reads it for slug suggestion and repairs. Nothing
+ * copies the members. Note that it is NOT the enumeration of built-in
+ * datapoints — the cloud keeps that separately, and it must, now that a
+ * reserved name exists that no plane serves.
+ *
+ * **What it does not do: `robotConfigDoc` does not enforce it.** Reservation is
+ * a semantic check that belongs with the ones that need the robot's context,
+ * and it answers as a `ValidationIssue` carrying the section, the slug and a
+ * severity — which a zod issue could not, and which is what the console's
+ * repair actions read. The section descriptions below therefore say "refused
+ * when the document is validated" rather than "refused here" — the artifact
+ * ships those sentences to readers who have only the JSON Schema, and
+ * "here" would have promised them a refusal this parse does not make.
+ */
+export declare const RESERVED_SLUGS: readonly ["bridge_state", "robot_details", "bridge_pressure", "history"];
+/**
+ * When an alert fires and when it is ok again. There is no discriminator:
+ * `resolve_at` absent means equality, present means a threshold whose
+ * direction follows from the comparison. The gap is the hysteresis, and it
+ * is therefore mandatory for thresholds — a value sitting exactly on a
+ * threshold with no gap flips on every sample.
+ */
+export declare const alertCondition: z.ZodObject<{
+    fire_at: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+    resolve_at: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type AlertCondition = z.infer<typeof alertCondition>;
+/**
+ * The four defaults the format names, as constants.
+ *
+ * **The fields stay `.optional()`, not `.default()`** — that argument is on
+ * `serviceDescription` above and has not changed: `.default()` publishes a
+ * field as *required* in the generated JSON Schema, and absence is the
+ * single spelling of "not set" in this format. What was missing is the
+ * number itself. Left only in prose, the cloud and the console each invent
+ * their own, and the two agree until one of them is edited. The house answer
+ * is a named constant, so a consumer applying a default reads it from here.
+ */
+export declare const ALERT_SEVERITY_DEFAULT = "warning";
+export declare const ALERT_ENABLED_DEFAULT = true;
+/** How often a value is written to history — not how often it is sent. */
+export declare const RETENTION_INTERVAL_SECONDS_DEFAULT = 300;
+/** The window a chart opens on, in minutes. Display only. */
+export declare const CHART_WINDOW_MINUTES_DEFAULT = 60;
+/**
+ * An alert's definition. Runtime state — whether it is firing, since when,
+ * with what value — is NOT here: it lives in the database and survives a
+ * restart, and it has no business in a versioned document.
+ *
+ * `severity` and `enabled` are absent-means-`ALERT_SEVERITY_DEFAULT` and
+ * absent-means-`ALERT_ENABLED_DEFAULT`; see those constants for why the
+ * default is not applied here.
+ */
+export declare const datapointAlert: z.ZodObject<{
+    condition: z.ZodObject<{
+        fire_at: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+        resolve_at: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    severity: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+    }>>;
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type DatapointAlert = z.infer<typeof datapointAlert>;
+/** Requires a numeric field — all four fields share that one precondition. */
+export declare const datapointNumeric: z.ZodObject<{
+    scale: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    unit: z.ZodOptional<z.ZodString>;
+    decimals: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type DatapointNumeric = z.infer<typeof datapointNumeric>;
+/**
+ * `interval_seconds` absent means `RETENTION_INTERVAL_SECONDS_DEFAULT`.
+ *
+ * **`enabled` absent means off**, and that direction is the deliberate one.
+ * Stored points are what a customer is billed for, so a default that silently
+ * turned history on would start charging for a value nobody asked to keep. The
+ * cheap mistake is a developer noticing a datapoint has no history and
+ * switching it on; the expensive one is nobody noticing that everything has
+ * history. Absent-means-off is also what the cloud already does — this comment
+ * exists because it was doing it without anything saying so.
+ *
+ * Not spelled `.default(false)` for the same reason as every other default in
+ * this file: the document a developer wrote is the document that is stored,
+ * and a parse that inserts fields makes the round trip a lie.
+ */
+export declare const datapointRetention: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    interval_seconds: z.ZodOptional<z.ZodNumber>;
+    max_buffer_values: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type DatapointRetention = z.infer<typeof datapointRetention>;
+export declare const datapointChart: z.ZodObject<{
+    y_min: z.ZodOptional<z.ZodNumber>;
+    y_max: z.ZodOptional<z.ZodNumber>;
+    style: z.ZodOptional<z.ZodEnum<{
+        line: "line";
+        step: "step";
+    }>>;
+    default_window_minutes: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type DatapointChart = z.infer<typeof datapointChart>;
+/**
+ * The ceiling lives here once. `rest.ts`'s `datapointDescriptor` reuses it,
+ * so the two cannot drift apart the way a number spelled out twice always
+ * eventually does. `0` is deliberately admitted — zero and "omitted"
+ * (`datapointConfig`) or `null` (`datapointDescriptor`) are the same fact,
+ * "no throttling", not a refused value: `.positive()` here would exclude
+ * the very thing this field's own absence already means.
+ */
+export declare const rateThrottleHz: z.ZodNumber;
+/**
+ * One exposed datapoint: one field of a topic, or the whole topic
+ * (`field` omitted). Never several topics.
+ *
+ * `rate_throttle_hz` is an upper bound, not a clock — the bridge drops what
+ * arrives too fast and never repeats a value to manufacture a rate. The
+ * ceiling is 20: an app's surface has no use for more, and a control loop
+ * belongs on a tool that reads at the robot.
+ */
+export declare const datapointConfig: z.ZodObject<{
+    topic: z.ZodString;
+    type: z.ZodString;
+    field: z.ZodOptional<z.ZodString>;
+    rate_throttle_hz: z.ZodOptional<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+    numeric: z.ZodOptional<z.ZodObject<{
+        scale: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        unit: z.ZodOptional<z.ZodString>;
+        decimals: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    retention: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        interval_seconds: z.ZodOptional<z.ZodNumber>;
+        max_buffer_values: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    chart: z.ZodOptional<z.ZodObject<{
+        y_min: z.ZodOptional<z.ZodNumber>;
+        y_max: z.ZodOptional<z.ZodNumber>;
+        style: z.ZodOptional<z.ZodEnum<{
+            line: "line";
+            step: "step";
+        }>>;
+        default_window_minutes: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    alerts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        condition: z.ZodObject<{
+            fire_at: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+            resolve_at: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        severity: z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            warning: "warning";
+        }>>;
+        name: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type DatapointConfig = z.infer<typeof datapointConfig>;
+/**
+ * A message template: the goal, request or published message, written out in
+ * full. Literals are fixed; `${name}` is a hole a caller fills.
+ *
+ * The shape cannot be narrower than `unknown` here — it is the shape of an
+ * arbitrary ROS message, which only the robot's own type definition knows.
+ * What CAN be checked here is the placeholder grammar; everything else is
+ * checked in the cloud against the introspected type.
+ *
+ * **`null` is refused, at every depth of this position.** Omission is the
+ * only spelling of "not set" in this format, and a bare `z.unknown()` made
+ * every message position the one place that also accepted the second
+ * spelling: `publishers.p.message: null`, `failsafe.message: null`,
+ * `actions.a.message: null` and `messages: {stop: null}` all parsed. Every
+ * other field gets this from its own type refusing `null`; this one has no
+ * type to get it from, so it says it here.
+ *
+ * The refusal is a refinement and therefore **invisible in the JSON Schema
+ * artifact**, which publishes this position as `{}`. The artifact says what
+ * the shape is, not what the parser refuses; a consumer that validates
+ * against the artifact instead of against this schema does not get it.
+ */
+export declare const messageTemplate: z.ZodUnknown;
+/** `${name}` and nothing else. A bare word is always a literal. */
+export declare const PLACEHOLDER_RE: RegExp;
+export declare const messageRef: z.ZodString;
+/**
+ * What may stand at a `message:` position: a shared message by name
+ * (`${name}`), or an inline template. Position decides which — directly after
+ * `message:` a `${name}` resolves to a shared message, inside a body it
+ * resolves to a parameter.
+ *
+ * **This is `messageTemplate`, not a union with `messageRef`, and that is a
+ * correction rather than a simplification.** It was written as
+ * `z.union([messageRef, messageTemplate])`, whose second member accepts
+ * everything the first does: the union could never refuse, never narrowed
+ * anything (`string | unknown` is `unknown`), and published as
+ * `anyOf: [{pattern: …}, {}]` — an artifact that claims a distinction no
+ * validator makes. The distinction is real but it is not a shape distinction:
+ * a `${name}` here means a reference and elsewhere means a parameter, and
+ * only the cloud can say whether that name is a defined message
+ * (`unknown_message`) or a nested one (`nested_message_reference`).
+ *
+ * `messageRef` stays exported as the predicate that decides it. It is what a
+ * consumer applies to a body to ask "is this a reference?"; it is not what
+ * validates one.
+ */
+export declare const messageBody: z.ZodUnknown;
+/**
+ * Every placeholder name in a template, at any depth.
+ *
+ * **An explicit stack, not recursion, and the reason is `safeParse`'s
+ * contract.** This runs inside `publisherConfig`'s failsafe refinement, so a
+ * `RangeError: Maximum call stack size exceeded` did not stay here: it
+ * propagated out of `safeParse`, which is specified to return a result and
+ * not to throw. Measured on the recursive version — fine at 8 000 levels of
+ * nesting, throwing at 20 000 — and a flow-style YAML one-liner reaches that
+ * in about 120 KB of input. A draft PUT would have answered 500 where it
+ * meant 400.
+ *
+ * `seen` is not an optimisation. YAML anchors can express a cycle
+ * (`&a { b: *a }`), and the parser resolves an alias to the same object, so
+ * without it the loop that fixed the overflow would hang instead — the
+ * failure mode a stack trades for, made worse by being silent.
+ *
+ * The array branch is explicit, not necessary: `Object.values()` on an array
+ * yields the same elements. It is here so the walk reads as covering both
+ * shapes; a reader does not have to know that property of `Object.values`.
+ */
+export declare function placeholderNames(node: unknown, found?: Set<string>): Set<string>;
+/**
+ * Reusable message bodies, keyed by name. A shared message may hold
+ * placeholders; whoever inserts it declares the parameters. It may NOT
+ * insert another — that excludes cycles and lets every check look at exactly
+ * one body instead of walking a reference tree.
+ */
+export declare const messageMap: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+/**
+ * An action the robot can be asked to perform (spec §4.2, §11.3). At most one
+ * job runs per action slug; a second call is refused `busy`, and every
+ * observer of the slug watches the same job.
+ */
+export declare const actionConfig: z.ZodObject<{
+    ros_name: z.ZodString;
+    type: z.ZodString;
+    message: z.ZodOptional<z.ZodUnknown>;
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<{
+            string: "string";
+            bool: "bool";
+            byte: "byte";
+            char: "char";
+            int8: "int8";
+            uint8: "uint8";
+            int16: "int16";
+            uint16: "uint16";
+            int32: "int32";
+            uint32: "uint32";
+            int64: "int64";
+            uint64: "uint64";
+            float32: "float32";
+            float64: "float64";
+            wstring: "wstring";
+        }>;
+        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+        min_value: z.ZodOptional<z.ZodNumber>;
+        max_value: z.ZodOptional<z.ZodNumber>;
+        enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        regex: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ActionConfig = z.infer<typeof actionConfig>;
+/** A ROS service call with validated parameters (spec §4.2). */
+export declare const serviceConfig: z.ZodObject<{
+    ros_name: z.ZodString;
+    type: z.ZodString;
+    message: z.ZodOptional<z.ZodUnknown>;
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<{
+            string: "string";
+            bool: "bool";
+            byte: "byte";
+            char: "char";
+            int8: "int8";
+            uint8: "uint8";
+            int16: "int16";
+            uint16: "uint16";
+            int32: "int32";
+            uint32: "uint32";
+            int64: "int64";
+            uint64: "uint64";
+            float32: "float32";
+            float64: "float64";
+            wstring: "wstring";
+        }>;
+        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+        min_value: z.ZodOptional<z.ZodNumber>;
+        max_value: z.ZodOptional<z.ZodNumber>;
+        enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        regex: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ServiceConfig = z.infer<typeof serviceConfig>;
+/**
+ * A topic clients may publish to.
+ *
+ * `failsafe` groups the deadline with the message it triggers, because the
+ * deadline exists for nothing else. The message must hold no placeholder:
+ * the bridge sends it with no caller present, so there would be nobody to
+ * fill one.
+ *
+ * **What that check can and cannot see.** It refuses a placeholder written
+ * into an inline failsafe body. It does not refuse
+ * `failsafe: { message: '${anything}' }` — a string at a `message:` position
+ * is a *reference to a shared message*, and whether that message holds a
+ * placeholder is a question about another section of the document, which a
+ * schema over one publisher cannot answer. So `failsafe_has_parameters` is
+ * half here and half in the cloud, on purpose and by position rather than by
+ * accident: the inline half is decidable here, the referenced half is one of
+ * the name-resolution codes the file header assigns to the cloud.
+ *
+ * `quiet_timeout_ms` is unrelated — how long a publisher must be silent
+ * before a *different* user may send.
+ */
+export declare const publisherConfig: z.ZodObject<{
+    topic: z.ZodString;
+    type: z.ZodString;
+    message: z.ZodUnknown;
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<{
+            string: "string";
+            bool: "bool";
+            byte: "byte";
+            char: "char";
+            int8: "int8";
+            uint8: "uint8";
+            int16: "int16";
+            uint16: "uint16";
+            int32: "int32";
+            uint32: "uint32";
+            int64: "int64";
+            uint64: "uint64";
+            float32: "float32";
+            float64: "float64";
+            wstring: "wstring";
+        }>;
+        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+        min_value: z.ZodOptional<z.ZodNumber>;
+        max_value: z.ZodOptional<z.ZodNumber>;
+        enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        regex: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    failsafe: z.ZodObject<{
+        timeout_ms: z.ZodNumber;
+        message: z.ZodUnknown;
+    }, z.core.$strict>;
+    quiet_timeout_ms: z.ZodNumber;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type PublisherConfig = z.infer<typeof publisherConfig>;
+/**
+ * Camera credentials, in the document. There is no separate store any more.
+ *
+ * This was decided against a recorded objection, and the objection stands: a
+ * password here is in every published version, and those are immutable. It
+ * cannot be removed from history and cannot be rotated without republishing.
+ * The bound on that decision is elsewhere and load-bearing — the publish
+ * audit event and the org event stream must not carry the document body.
+ */
+export declare const cameraCredentials: z.ZodObject<{
+    username: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CameraCredentials = z.infer<typeof cameraCredentials>;
+export declare const cameraSource: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"ros">;
+    topic: z.ZodString;
+    type: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"rtsp">;
+    url: z.ZodString;
+    transport: z.ZodOptional<z.ZodEnum<{
+        tcp: "tcp";
+        udp: "udp";
+    }>>;
+    credentials: z.ZodOptional<z.ZodObject<{
+        username: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"mjpeg">;
+    url: z.ZodString;
+    credentials: z.ZodOptional<z.ZodObject<{
+        username: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"v4l2">;
+    device: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type CameraSource = z.infer<typeof cameraSource>;
+/**
+ * How often a snapshot is captured, in seconds. Bounded below at one second
+ * because a snapshot is the *cheap* mode — a developer who wants motion wants
+ * live, and an interval faster than this is a live stream wearing a disguise.
+ *
+ * The bound lives here once, and `rest.ts`'s `cameraDescriptor` reuses it —
+ * the same treatment `rateThrottleHz` got, and for the same reason: the
+ * descriptor used to say `snapshot_interval_ms` while the document said
+ * seconds, so the cloud converted on one descriptor and not its sibling, with
+ * nothing in either file saying so.
+ */
+export declare const snapshotIntervalSeconds: z.ZodNumber;
+/**
+ * A camera the robot exposes (spec §10).
+ *
+ * `width`/`height`/`fps`/`bitrate_kbps` are not cosmetic: §10 makes them the
+ * developer's control over **the robot's own bandwidth**, which is why they
+ * live in the configuration rather than in a viewer's request. A viewer never
+ * gets to make a robot send more.
+ *
+ * The two modes are deliberately independent (§10):
+ *
+ * - **Snapshot** runs always, at `snapshot_interval_seconds`, whether or not
+ *   anyone is watching live. The cloud caches the one frame and serves every
+ *   client from it, so a hundred pollers cost the robot exactly one image per
+ *   interval.
+ * - **Live** runs on demand and is refcounted in the cloud: the first viewer
+ *   starts it, the last one ends it.
+ */
+export declare const cameraConfig: z.ZodObject<{
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"ros">;
+        topic: z.ZodString;
+        type: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"rtsp">;
+        url: z.ZodString;
+        transport: z.ZodOptional<z.ZodEnum<{
+            tcp: "tcp";
+            udp: "udp";
+        }>>;
+        credentials: z.ZodOptional<z.ZodObject<{
+            username: z.ZodOptional<z.ZodString>;
+            password: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"mjpeg">;
+        url: z.ZodString;
+        credentials: z.ZodOptional<z.ZodObject<{
+            username: z.ZodOptional<z.ZodString>;
+            password: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"v4l2">;
+        device: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    fps: z.ZodNumber;
+    bitrate_kbps: z.ZodNumber;
+    snapshot_interval_seconds: z.ZodNumber;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CameraConfig = z.infer<typeof cameraConfig>;
+/**
+ * The format version of a `fleetless.yaml`. Deliberately not called
+ * `version`: the console counts published states with "v12 → v13", and two
+ * numbers called version would be the likeliest confusion in the format.
+ */
+export declare const FLEETLESS_FORMAT_VERSION = 1;
+/**
+ * A whole robot configuration — everything configurable about one robot.
+ *
+ * Every section is a mapping keyed by name, not a list of objects carrying
+ * their own name. A duplicate name is then a YAML syntax error rather than a
+ * rule somebody has to write, and the name reads as the entry's heading.
+ *
+ * Slugs remain ONE namespace across all five exposure sections (§4.1), which
+ * is what lets a role grant say `{robot, slug}` without naming a kind. That
+ * check spans sections and therefore lives in the cloud, not here.
+ */
+export declare const robotConfigDoc: z.ZodObject<{
+    fleetless: z.ZodLiteral<1>;
+    messages: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    datapoints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        topic: z.ZodString;
+        type: z.ZodString;
+        field: z.ZodOptional<z.ZodString>;
+        rate_throttle_hz: z.ZodOptional<z.ZodNumber>;
+        description: z.ZodOptional<z.ZodString>;
+        numeric: z.ZodOptional<z.ZodObject<{
+            scale: z.ZodOptional<z.ZodNumber>;
+            offset: z.ZodOptional<z.ZodNumber>;
+            unit: z.ZodOptional<z.ZodString>;
+            decimals: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        retention: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            interval_seconds: z.ZodOptional<z.ZodNumber>;
+            max_buffer_values: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        chart: z.ZodOptional<z.ZodObject<{
+            y_min: z.ZodOptional<z.ZodNumber>;
+            y_max: z.ZodOptional<z.ZodNumber>;
+            style: z.ZodOptional<z.ZodEnum<{
+                line: "line";
+                step: "step";
+            }>>;
+            default_window_minutes: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        alerts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            condition: z.ZodObject<{
+                fire_at: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                resolve_at: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+            severity: z.ZodOptional<z.ZodEnum<{
+                error: "error";
+                warning: "warning";
+            }>>;
+            name: z.ZodOptional<z.ZodString>;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        ros_name: z.ZodString;
+        type: z.ZodString;
+        message: z.ZodOptional<z.ZodUnknown>;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                bool: "bool";
+                byte: "byte";
+                char: "char";
+                int8: "int8";
+                uint8: "uint8";
+                int16: "int16";
+                uint16: "uint16";
+                int32: "int32";
+                uint32: "uint32";
+                int64: "int64";
+                uint64: "uint64";
+                float32: "float32";
+                float64: "float64";
+                wstring: "wstring";
+            }>;
+            default: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            min_value: z.ZodOptional<z.ZodNumber>;
+            max_value: z.ZodOptional<z.ZodNumber>;
+            enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+            regex: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    services: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        ros_name: z.ZodString;
+        type: z.ZodString;
+        message: z.ZodOptional<z.ZodUnknown>;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                bool: "bool";
+                byte: "byte";
+                char: "char";
+                int8: "int8";
+                uint8: "uint8";
+                int16: "int16";
+                uint16: "uint16";
+                int32: "int32";
+                uint32: "uint32";
+                int64: "int64";
+                uint64: "uint64";
+                float32: "float32";
+                float64: "float64";
+                wstring: "wstring";
+            }>;
+            default: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            min_value: z.ZodOptional<z.ZodNumber>;
+            max_value: z.ZodOptional<z.ZodNumber>;
+            enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+            regex: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    publishers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        topic: z.ZodString;
+        type: z.ZodString;
+        message: z.ZodUnknown;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                bool: "bool";
+                byte: "byte";
+                char: "char";
+                int8: "int8";
+                uint8: "uint8";
+                int16: "int16";
+                uint16: "uint16";
+                int32: "int32";
+                uint32: "uint32";
+                int64: "int64";
+                uint64: "uint64";
+                float32: "float32";
+                float64: "float64";
+                wstring: "wstring";
+            }>;
+            default: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            min_value: z.ZodOptional<z.ZodNumber>;
+            max_value: z.ZodOptional<z.ZodNumber>;
+            enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+            regex: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        failsafe: z.ZodObject<{
+            timeout_ms: z.ZodNumber;
+            message: z.ZodUnknown;
+        }, z.core.$strict>;
+        quiet_timeout_ms: z.ZodNumber;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    cameras: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"ros">;
+            topic: z.ZodString;
+            type: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"rtsp">;
+            url: z.ZodString;
+            transport: z.ZodOptional<z.ZodEnum<{
+                tcp: "tcp";
+                udp: "udp";
+            }>>;
+            credentials: z.ZodOptional<z.ZodObject<{
+                username: z.ZodOptional<z.ZodString>;
+                password: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"mjpeg">;
+            url: z.ZodString;
+            credentials: z.ZodOptional<z.ZodObject<{
+                username: z.ZodOptional<z.ZodString>;
+                password: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"v4l2">;
+            device: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        fps: z.ZodNumber;
+        bitrate_kbps: z.ZodNumber;
+        snapshot_interval_seconds: z.ZodNumber;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type RobotConfigDoc = z.infer<typeof robotConfigDoc>;
+/**
+ * One thing the cloud has to say about a configuration (spec §11.5: field +
+ * violated rule).
+ *
+ * `error` blocks the publish. `warning` does not — an unknown topic is a
+ * warning on purpose, because configuring a robot that has never been
+ * connected must stay possible (spec §4.1).
+ */
+export declare const validationIssue: z.ZodObject<{
+    path: z.ZodString;
+    slug: z.ZodNullable<z.ZodString>;
+    code: z.ZodString;
+    message: z.ZodString;
+    severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+    }>;
+}, z.core.$strip>;
+export type ValidationIssue = z.infer<typeof validationIssue>;
+/**
+ * Where a robot's configuration stands — the material for the console's
+ * "draft newer than published", "published v2 · applied v1 · bridge offline"
+ * (spec §15.2, robot tab 1).
+ */
+export declare const configState: z.ZodObject<{
+    published_version: z.ZodNullable<z.ZodNumber>;
+    published_at: z.ZodNullable<z.ZodISODateTime>;
+    draft_updated_at: z.ZodNullable<z.ZodISODateTime>;
+    applied_version: z.ZodNullable<z.ZodNumber>;
+    applied_ok: z.ZodNullable<z.ZodBoolean>;
+    applied_errors: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        kind: z.ZodEnum<{
+            datapoint: "datapoint";
+            action: "action";
+            service: "service";
+            publisher: "publisher";
+            camera: "camera";
+        }>;
+        code: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ConfigState = z.infer<typeof configState>;