@camstack/types 1.2.327 → 1.2.329

package/dist/capabilities/keychain-admin.cap.d.ts

@@ -0,0 +1,312 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * `keychain-admin` — the operator's view of the keychain (System → Secrets).
+ *
+ * Every method is `admin`. Two methods hand out material, each audited and
+ * each named for exactly that: {@link keychainAdminCapability.methods.reveal}
+ * (one value, shown briefly by the UI) and `downloadRecoveryKey` (the master
+ * key itself, so the operator can keep a copy off the hub). Nothing else
+ * returns a value.
+ *
+ * The master key's LOCATION is configuration, never an env var (D788):
+ * `keychain.keyFile` in `config.yaml`, the OS keychain on a desktop hub, else
+ * `<dataDir>/.keychain/master.key` — which sits beside the database in every
+ * whole-volume backup, and the status says so.
+ */
+/** Where the master key in use came from. */
+export declare const KeychainKeySourceKindSchema: z.ZodEnum<{
+    platform: "platform";
+    "config-file": "config-file";
+    "previous-config-file": "previous-config-file";
+    "default-file": "default-file";
+}>;
+export type KeychainKeySourceKind = z.infer<typeof KeychainKeySourceKindSchema>;
+export declare const KeychainKeySourceSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        platform: "platform";
+        "config-file": "config-file";
+        "previous-config-file": "previous-config-file";
+        "default-file": "default-file";
+    }>;
+    path: z.ZodOptional<z.ZodString>;
+    sharesBackupWithDatabase: z.ZodBoolean;
+}, z.core.$strip>;
+export type KeychainKeySource = z.infer<typeof KeychainKeySourceSchema>;
+export declare const KeychainStatusSchema: z.ZodObject<{
+    keychain: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        state: z.ZodLiteral<"ready">;
+    }, z.core.$strip>, z.ZodObject<{
+        state: z.ZodLiteral<"locked">;
+        reason: z.ZodEnum<{
+            "key-missing": "key-missing";
+            "wrong-key": "wrong-key";
+            "key-file-unreadable": "key-file-unreadable";
+            "store-unavailable": "store-unavailable";
+            "not-initialized": "not-initialized";
+            "decrypt-failed": "decrypt-failed";
+        }>;
+    }, z.core.$strip>], "state">;
+    keySource: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            platform: "platform";
+            "config-file": "config-file";
+            "previous-config-file": "previous-config-file";
+            "default-file": "default-file";
+        }>;
+        path: z.ZodOptional<z.ZodString>;
+        sharesBackupWithDatabase: z.ZodBoolean;
+    }, z.core.$strip>>;
+    configuredSource: z.ZodObject<{
+        kind: z.ZodEnum<{
+            platform: "platform";
+            "config-file": "config-file";
+            "previous-config-file": "previous-config-file";
+            "default-file": "default-file";
+        }>;
+        path: z.ZodOptional<z.ZodString>;
+        sharesBackupWithDatabase: z.ZodBoolean;
+    }, z.core.$strip>;
+    fingerprint: z.ZodNullable<z.ZodString>;
+    activeKeyId: z.ZodNullable<z.ZodString>;
+    rotationPending: z.ZodBoolean;
+    retiredWraps: z.ZodNumber;
+    recoveryKeyDownloadedAt: z.ZodNullable<z.ZodNumber>;
+    secretCount: z.ZodNumber;
+}, z.core.$strip>;
+export type KeychainStatus = z.infer<typeof KeychainStatusSchema>;
+/**
+ * Whether a stored value is still pointed at by its owner's settings.
+ * `unknown` is a first-class answer: a scope whose blob could not be read is
+ * never reported as an orphan (and never deleted as one).
+ */
+export declare const KeychainSecretUsageSchema: z.ZodEnum<{
+    unknown: "unknown";
+    "in-use": "in-use";
+    orphan: "orphan";
+}>;
+export type KeychainSecretUsage = z.infer<typeof KeychainSecretUsageSchema>;
+export declare const KeychainAdminSecretSchema: z.ZodObject<{
+    ref: z.ZodString;
+    owner: z.ZodString;
+    scope: z.ZodString;
+    fieldPath: z.ZodString;
+    version: z.ZodNumber;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    updatedBy: z.ZodString;
+    lastReadAt: z.ZodNullable<z.ZodNumber>;
+    usage: z.ZodEnum<{
+        unknown: "unknown";
+        "in-use": "in-use";
+        orphan: "orphan";
+    }>;
+}, z.core.$strip>;
+export type KeychainAdminSecret = z.infer<typeof KeychainAdminSecretSchema>;
+export declare const KeychainAuditActionSchema: z.ZodEnum<{
+    delete: "delete";
+    reset: "reset";
+    put: "put";
+    reveal: "reveal";
+    "rotate-master-key": "rotate-master-key";
+    "purge-retired-keys": "purge-retired-keys";
+    "download-recovery-key": "download-recovery-key";
+    "delete-orphans": "delete-orphans";
+    initialize: "initialize";
+}>;
+export type KeychainAuditAction = z.infer<typeof KeychainAuditActionSchema>;
+export declare const KeychainAuditEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    at: z.ZodNumber;
+    action: z.ZodEnum<{
+        delete: "delete";
+        reset: "reset";
+        put: "put";
+        reveal: "reveal";
+        "rotate-master-key": "rotate-master-key";
+        "purge-retired-keys": "purge-retired-keys";
+        "download-recovery-key": "download-recovery-key";
+        "delete-orphans": "delete-orphans";
+        initialize: "initialize";
+    }>;
+    actor: z.ZodString;
+    ref: z.ZodNullable<z.ZodString>;
+    detail: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type KeychainAuditEntry = z.infer<typeof KeychainAuditEntrySchema>;
+export declare const KEYCHAIN_RESET_CONFIRMATION = "RESET KEYCHAIN";
+export declare const keychainAdminCapability: {
+    readonly name: "keychain-admin";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        readonly status: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+            keychain: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                state: z.ZodLiteral<"ready">;
+            }, z.core.$strip>, z.ZodObject<{
+                state: z.ZodLiteral<"locked">;
+                reason: z.ZodEnum<{
+                    "key-missing": "key-missing";
+                    "wrong-key": "wrong-key";
+                    "key-file-unreadable": "key-file-unreadable";
+                    "store-unavailable": "store-unavailable";
+                    "not-initialized": "not-initialized";
+                    "decrypt-failed": "decrypt-failed";
+                }>;
+            }, z.core.$strip>], "state">;
+            keySource: z.ZodNullable<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    platform: "platform";
+                    "config-file": "config-file";
+                    "previous-config-file": "previous-config-file";
+                    "default-file": "default-file";
+                }>;
+                path: z.ZodOptional<z.ZodString>;
+                sharesBackupWithDatabase: z.ZodBoolean;
+            }, z.core.$strip>>;
+            configuredSource: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    platform: "platform";
+                    "config-file": "config-file";
+                    "previous-config-file": "previous-config-file";
+                    "default-file": "default-file";
+                }>;
+                path: z.ZodOptional<z.ZodString>;
+                sharesBackupWithDatabase: z.ZodBoolean;
+            }, z.core.$strip>;
+            fingerprint: z.ZodNullable<z.ZodString>;
+            activeKeyId: z.ZodNullable<z.ZodString>;
+            rotationPending: z.ZodBoolean;
+            retiredWraps: z.ZodNumber;
+            recoveryKeyDownloadedAt: z.ZodNullable<z.ZodNumber>;
+            secretCount: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly listSecrets: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            ref: z.ZodString;
+            owner: z.ZodString;
+            scope: z.ZodString;
+            fieldPath: z.ZodString;
+            version: z.ZodNumber;
+            createdAt: z.ZodNumber;
+            updatedAt: z.ZodNumber;
+            updatedBy: z.ZodString;
+            lastReadAt: z.ZodNullable<z.ZodNumber>;
+            usage: z.ZodEnum<{
+                unknown: "unknown";
+                "in-use": "in-use";
+                orphan: "orphan";
+            }>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly listAudit: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            at: z.ZodNumber;
+            action: z.ZodEnum<{
+                delete: "delete";
+                reset: "reset";
+                put: "put";
+                reveal: "reveal";
+                "rotate-master-key": "rotate-master-key";
+                "purge-retired-keys": "purge-retired-keys";
+                "download-recovery-key": "download-recovery-key";
+                "delete-orphans": "delete-orphans";
+                initialize: "initialize";
+            }>;
+            actor: z.ZodString;
+            ref: z.ZodNullable<z.ZodString>;
+            detail: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Show one value to the operator. Audited. The UI hides it again after a
+         * few seconds; nothing caches it.
+         */
+        readonly reveal: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            ref: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            value: z.ZodString;
+            version: z.ZodNumber;
+        }, z.core.$strip>, "mutation"> & {
+            readonly caller: "required";
+        };
+        /** Delete refs no owner points at any more. Re-checked here; `unknown` is kept. */
+        readonly deleteOrphans: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            refs: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            deleted: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            kept: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                ref: z.ZodString;
+                usage: z.ZodEnum<{
+                    unknown: "unknown";
+                    "in-use": "in-use";
+                    orphan: "orphan";
+                }>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, "mutation"> & {
+            readonly caller: "required";
+        };
+        /**
+         * Wrap the data key under the configured primary master key.
+         *
+         * Pending rotation (the keychain unlocked with a previous source): re-wrap
+         * under the primary. Otherwise, with the default file as primary: generate
+         * a new master key, write it there, re-wrap. A file or OS-keychain primary
+         * that is already in use cannot be replaced from here — put the new key at
+         * the source, keep the old one as `keychain.previousKeyFile`, restart, and
+         * rotate. No value is re-encrypted either way; the previous wrap is kept
+         * (retired) until purged.
+         */
+        readonly rotateMasterKey: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+            fingerprint: z.ZodString;
+            keySource: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    platform: "platform";
+                    "config-file": "config-file";
+                    "previous-config-file": "previous-config-file";
+                    "default-file": "default-file";
+                }>;
+                path: z.ZodOptional<z.ZodString>;
+                sharesBackupWithDatabase: z.ZodBoolean;
+            }, z.core.$strip>;
+        }, z.core.$strip>, "mutation"> & {
+            readonly caller: "required";
+        };
+        readonly purgeRetiredKeys: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+            purged: z.ZodNumber;
+        }, z.core.$strip>, "mutation"> & {
+            readonly caller: "required";
+        };
+        /** The master key, base64. Audited; marks the recovery copy as taken. */
+        readonly downloadRecoveryKey: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+            key: z.ZodString;
+            fingerprint: z.ZodString;
+            keySource: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    platform: "platform";
+                    "config-file": "config-file";
+                    "previous-config-file": "previous-config-file";
+                    "default-file": "default-file";
+                }>;
+                path: z.ZodOptional<z.ZodString>;
+                sharesBackupWithDatabase: z.ZodBoolean;
+            }, z.core.$strip>;
+        }, z.core.$strip>, "mutation"> & {
+            readonly caller: "required";
+        };
+        /**
+         * Lost-key recovery: archive every stored value into a
+         * `keychain:secrets-orphaned-<ts>` table and start over with a new data
+         * key. Every secret field then reads "not set". Requires the typed
+         * confirmation {@link KEYCHAIN_RESET_CONFIRMATION}.
+         */
+        readonly resetKeychain: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            confirm: z.ZodLiteral<"RESET KEYCHAIN">;
+        }, z.core.$strip>, z.ZodObject<{
+            archivedCollection: z.ZodNullable<z.ZodString>;
+            archived: z.ZodNumber;
+        }, z.core.$strip>, "mutation"> & {
+            readonly caller: "required";
+        };
+    };
+};
+export type IKeychainAdminProvider = InferProvider<typeof keychainAdminCapability>;

package/dist/capabilities/keychain.cap.d.ts

@@ -0,0 +1,180 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * `keychain` — the hub's encrypted store of secret values (D787).
+ *
+ * Settings blobs never hold a secret: they hold a marker
+ * `{"$secret":"secret://<owner>/<scope>/<fieldPath>","v":1}` and the value
+ * lives here, AES-256-GCM under a data key that a master key wraps. This cap
+ * is the OWNER's door to its own values: every method is owner-checked
+ * against the CALLER, never against anything the caller claims.
+ *
+ * Who the caller is: the transport stamps `callerAddonId` into the args of a
+ * call that crossed a process (the parent `LocalChildRegistry` from the UDS
+ * connection, the agent from its child's connection carried in
+ * `$hub-cap-fwd`'s envelope). A stamp always overwrites; a wire call with no
+ * stamp has its claim stripped. Only a hub in-process caller may state its own
+ * identity — `ctx.secrets` does that with the addon id closed over. This is
+ * identity against BUGS and misrouting, not against a malicious addon (every
+ * runner is the same OS user): see the threat model in
+ * `docs/design/2026-10-08-secrets-keychain.md`.
+ *
+ * `callerAddonId` is deliberately NOT in any input schema: the tRPC router
+ * parses the input, so a session can never supply it, and the internal mount
+ * floors every method to admin anyway (D240).
+ *
+ * Internal: addons reach it through `ctx.secrets`, never directly.
+ */
+/** Why a value cannot be served right now. Never folded into "missing". */
+export declare const KeychainUnavailableReasonSchema: z.ZodEnum<{
+    "key-missing": "key-missing";
+    "wrong-key": "wrong-key";
+    "key-file-unreadable": "key-file-unreadable";
+    "store-unavailable": "store-unavailable";
+    "not-initialized": "not-initialized";
+    "decrypt-failed": "decrypt-failed";
+}>;
+export type KeychainUnavailableReason = z.infer<typeof KeychainUnavailableReasonSchema>;
+export declare const KeychainStateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    state: z.ZodLiteral<"ready">;
+}, z.core.$strip>, z.ZodObject<{
+    state: z.ZodLiteral<"locked">;
+    reason: z.ZodEnum<{
+        "key-missing": "key-missing";
+        "wrong-key": "wrong-key";
+        "key-file-unreadable": "key-file-unreadable";
+        "store-unavailable": "store-unavailable";
+        "not-initialized": "not-initialized";
+        "decrypt-failed": "decrypt-failed";
+    }>;
+}, z.core.$strip>], "state">;
+export type KeychainState = z.infer<typeof KeychainStateSchema>;
+export declare const KeychainResolveEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"value">;
+    value: z.ZodString;
+    version: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"missing">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"unavailable">;
+    reason: z.ZodEnum<{
+        "key-missing": "key-missing";
+        "wrong-key": "wrong-key";
+        "key-file-unreadable": "key-file-unreadable";
+        "store-unavailable": "store-unavailable";
+        "not-initialized": "not-initialized";
+        "decrypt-failed": "decrypt-failed";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"forbidden">;
+}, z.core.$strip>], "kind">;
+export type KeychainResolveEntry = z.infer<typeof KeychainResolveEntrySchema>;
+export declare const KeychainResolveResultSchema: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"value">;
+    value: z.ZodString;
+    version: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"missing">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"unavailable">;
+    reason: z.ZodEnum<{
+        "key-missing": "key-missing";
+        "wrong-key": "wrong-key";
+        "key-file-unreadable": "key-file-unreadable";
+        "store-unavailable": "store-unavailable";
+        "not-initialized": "not-initialized";
+        "decrypt-failed": "decrypt-failed";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"forbidden">;
+}, z.core.$strip>], "kind">>;
+export type KeychainResolveResult = z.infer<typeof KeychainResolveResultSchema>;
+/** Metadata of one stored value — never the value. */
+export declare const KeychainSecretMetaSchema: z.ZodObject<{
+    ref: z.ZodString;
+    owner: z.ZodString;
+    scope: z.ZodString;
+    fieldPath: z.ZodString;
+    version: z.ZodNumber;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    updatedBy: z.ZodString;
+    lastReadAt: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type KeychainSecretMeta = z.infer<typeof KeychainSecretMetaSchema>;
+/** A batch bound: one `resolveConfig` resolves every marker of one blob at once. */
+export declare const KEYCHAIN_MAX_REFS_PER_CALL = 512;
+export declare const keychainCapability: {
+    readonly name: "keychain";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly internal: true;
+    readonly methods: {
+        /** Store (or replace) the caller's value at `ref`. Refused while locked. */
+        readonly put: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            ref: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            ref: z.ZodString;
+            version: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Resolve the caller's refs in one round-trip. A locked keychain answers
+         * `unavailable` per ref — never `missing`, never an empty value.
+         */
+        readonly resolve: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            refs: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"value">;
+            value: z.ZodString;
+            version: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"missing">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                "key-missing": "key-missing";
+                "wrong-key": "wrong-key";
+                "key-file-unreadable": "key-file-unreadable";
+                "store-unavailable": "store-unavailable";
+                "not-initialized": "not-initialized";
+                "decrypt-failed": "decrypt-failed";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"forbidden">;
+        }, z.core.$strip>], "kind">>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Remove the caller's refs. Unknown refs are ignored. */
+        readonly delete: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            refs: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            deleted: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
+        /** The caller's own refs, metadata only. */
+        readonly listMeta: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            ref: z.ZodString;
+            owner: z.ZodString;
+            scope: z.ZodString;
+            fieldPath: z.ZodString;
+            version: z.ZodNumber;
+            createdAt: z.ZodNumber;
+            updatedAt: z.ZodNumber;
+            updatedBy: z.ZodString;
+            lastReadAt: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Whether values can be served — the save path refuses a write while locked. */
+        readonly getState: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"ready">;
+        }, z.core.$strip>, z.ZodObject<{
+            state: z.ZodLiteral<"locked">;
+            reason: z.ZodEnum<{
+                "key-missing": "key-missing";
+                "wrong-key": "wrong-key";
+                "key-file-unreadable": "key-file-unreadable";
+                "store-unavailable": "store-unavailable";
+                "not-initialized": "not-initialized";
+                "decrypt-failed": "decrypt-failed";
+            }>;
+        }, z.core.$strip>], "state">, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IKeychainProvider = InferProvider<typeof keychainCapability>;

package/dist/capabilities/lawn-mower-control.cap.d.ts

@@ -22,8 +22,8 @@ export declare const LawnMowerActivitySchema: z.ZodEnum<{
 export type LawnMowerActivity = z.infer<typeof LawnMowerActivitySchema>;
 /** Severity of the current device/error code — info (status), warning, error. */
 export declare const DeviceCodeSeveritySchema: z.ZodEnum<{
-    error: "error";
     info: "info";
+    error: "error";
     warning: "warning";
 }>;
 export type DeviceCodeSeverity = z.infer<typeof DeviceCodeSeveritySchema>;
@@ -40,8 +40,8 @@ export declare const LawnMowerControlStatusSchema: z.ZodObject<{
     currentCode: z.ZodNullable<z.ZodNumber>;
     currentCodeLabel: z.ZodNullable<z.ZodString>;
     severity: z.ZodEnum<{
-        error: "error";
         info: "info";
+        error: "error";
         warning: "warning";
     }>;
     lastChangedAt: z.ZodNumber;
@@ -78,8 +78,8 @@ export declare const lawnMowerControlCapability: {
             currentCode: z.ZodNullable<z.ZodNumber>;
             currentCodeLabel: z.ZodNullable<z.ZodString>;
             severity: z.ZodEnum<{
-                error: "error";
                 info: "info";
+                error: "error";
                 warning: "warning";
             }>;
             lastChangedAt: z.ZodNumber;
@@ -103,8 +103,8 @@ export declare const lawnMowerControlCapability: {
         currentCode: z.ZodNullable<z.ZodNumber>;
         currentCodeLabel: z.ZodNullable<z.ZodString>;
         severity: z.ZodEnum<{
-            error: "error";
             info: "info";
+            error: "error";
             warning: "warning";
         }>;
         lastChangedAt: z.ZodNumber;

package/dist/capabilities/log-channels.cap.d.ts

@@ -57,8 +57,8 @@ export declare const logChannelsCapability: {
             name: z.ZodString;
             description: z.ZodString;
             defaultLevel: z.ZodEnum<{
-                error: "error";
                 info: "info";
+                error: "error";
                 warn: "warn";
             }>;
             perDevice: z.ZodBoolean;

package/dist/capabilities/log-destination.cap.d.ts

@@ -1,17 +1,17 @@
 import { z } from 'zod';
 import { type InferProvider } from './capability-definition.js';
 declare const LogLevelSchema: z.ZodEnum<{
+    info: "info";
     error: "error";
     debug: "debug";
-    info: "info";
     warn: "warn";
 }>;
 declare const LogEntrySchema: z.ZodObject<{
     timestamp: z.ZodDate;
     level: z.ZodEnum<{
+        info: "info";
         error: "error";
         debug: "debug";
-        info: "info";
         warn: "warn";
     }>;
     scope: z.ZodArray<z.ZodString>;
@@ -28,9 +28,9 @@ export declare const logDestinationCapability: {
         readonly write: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             timestamp: z.ZodDate;
             level: z.ZodEnum<{
+                info: "info";
                 error: "error";
                 debug: "debug";
-                info: "info";
                 warn: "warn";
             }>;
             scope: z.ZodArray<z.ZodString>;
@@ -41,9 +41,9 @@ export declare const logDestinationCapability: {
         readonly query: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
             level: z.ZodOptional<z.ZodEnum<{
+                info: "info";
                 error: "error";
                 debug: "debug";
-                info: "info";
                 warn: "warn";
             }>>;
             since: z.ZodOptional<z.ZodDate>;
@@ -53,9 +53,9 @@ export declare const logDestinationCapability: {
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             timestamp: z.ZodDate;
             level: z.ZodEnum<{
+                info: "info";
                 error: "error";
                 debug: "debug";
-                info: "info";
                 warn: "warn";
             }>;
             scope: z.ZodArray<z.ZodString>;