@camstack/types 1.2.112 → 1.2.114

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

@@ -102,6 +102,424 @@ declare const SetSiteLocationInputSchema: z.ZodNullable<z.ZodObject<{
     latitude: z.ZodNumber;
     longitude: z.ZodNumber;
 }, z.core.$strip>>;
+/**
+ * The TRANSPORT a call arrived on.
+ *
+ * Every counted call carries exactly one of these, and `unknown` is a PLANE
+ * rather than a gap: a plane that cannot attribute a call declares it here, so
+ * the call lands in a named bucket instead of vanishing. `planes` summing to
+ * `procedureCalls` is what makes "the sum of the planes explains the total"
+ * checkable rather than asserted.
+ *
+ *  - `http`  — the Fastify tRPC plugin (`/trpc/*`), one context per request.
+ *  - `ws`    — `applyWSSHandler`, counted per OPERATION rather than per
+ *              connection; the viewer talks to the hub over `wsLink`
+ *              exclusively, so this is the plane the HTTP census could not see.
+ *  - `mesh`  — the in-process `$core-caps` bridge (`createCaller`), which
+ *              never touches a socket and therefore never touched a census.
+ *  - `unknown` — counted, plane undecidable. No hook produces it today, and
+ *    that is exactly what its `0` asserts: every plane the hub has can name
+ *    itself. It is an output bucket, never a knob — a call that arrives on a
+ *    plane nobody instrumented lands here instead of vanishing from the total.
+ */
+declare const TransportPlaneSchema: z.ZodEnum<{
+    unknown: "unknown";
+    mesh: "mesh";
+    http: "http";
+    ws: "ws";
+}>;
+/**
+ * Calls per plane. Every key is always present, `0` included — an absent plane
+ * reads as "not instrumented", which is the one thing this census must never
+ * make an operator wonder about.
+ */
+declare const TransportPlaneCountsSchema: z.ZodObject<{
+    http: z.ZodNumber;
+    ws: z.ZodNumber;
+    mesh: z.ZodNumber;
+    unknown: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * One `(plane, procedure, user-agent, ip, principal)` tuple of the transport
+ * census. `principal` is the DERIVED identity (`apocaliss92 (admin)`,
+ * `scoped:1a2b3c4d (scoped-token)`, `anonymous`) that the tRPC error log
+ * already prints - never a token, never an `Authorization` header.
+ *
+ * `subscriptions` is counted APART from `calls`: a subscription is opened once
+ * and lives for hours, so folding it into a call count makes one long-lived
+ * stream look like a storm.
+ */
+declare const RequestCensusGroupSchema: z.ZodObject<{
+    plane: z.ZodEnum<{
+        unknown: "unknown";
+        mesh: "mesh";
+        http: "http";
+        ws: "ws";
+    }>;
+    procedure: z.ZodString;
+    userAgent: z.ZodString;
+    ip: z.ZodString;
+    principal: z.ZodString;
+    calls: z.ZodNumber;
+    subscriptions: z.ZodNumber;
+    perMin: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * A procedure's TOTAL over the window, across every caller.
+ *
+ * This block, not the group list, is what answers "did these calls arrive over
+ * HTTP at all". A total far BELOW what a store-side census counted over the
+ * same window excludes the HTTP plane, which is a result, not a failure.
+ */
+declare const RequestCensusProcedureSchema: z.ZodObject<{
+    procedure: z.ZodString;
+    calls: z.ZodNumber;
+    planes: z.ZodObject<{
+        http: z.ZodNumber;
+        ws: z.ZodNumber;
+        mesh: z.ZodNumber;
+        unknown: z.ZodNumber;
+    }, z.core.$strip>;
+    subscriptions: z.ZodNumber;
+    perMin: z.ZodNumber;
+}, z.core.$strip>;
+/** What one armed window measured. Mirrors `TransportCensus.snapshot()`. */
+declare const RequestCensusSnapshotSchema: z.ZodObject<{
+    armed: z.ZodBoolean;
+    elapsedMs: z.ZodNumber;
+    windowMs: z.ZodNumber;
+    armedUntilMs: z.ZodNumber;
+    httpRequests: z.ZodNumber;
+    batchedRequests: z.ZodNumber;
+    procedureCalls: z.ZodNumber;
+    planes: z.ZodObject<{
+        http: z.ZodNumber;
+        ws: z.ZodNumber;
+        mesh: z.ZodNumber;
+        unknown: z.ZodNumber;
+    }, z.core.$strip>;
+    planesExplainTotal: z.ZodBoolean;
+    wsConnections: z.ZodNumber;
+    wsMessages: z.ZodNumber;
+    subscriptions: z.ZodNumber;
+    subscriptionStops: z.ZodNumber;
+    distinctGroups: z.ZodNumber;
+    unattributedCalls: z.ZodNumber;
+    procedures: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        procedure: z.ZodString;
+        calls: z.ZodNumber;
+        planes: z.ZodObject<{
+            http: z.ZodNumber;
+            ws: z.ZodNumber;
+            mesh: z.ZodNumber;
+            unknown: z.ZodNumber;
+        }, z.core.$strip>;
+        subscriptions: z.ZodNumber;
+        perMin: z.ZodNumber;
+    }, z.core.$strip>>>;
+    groups: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        plane: z.ZodEnum<{
+            unknown: "unknown";
+            mesh: "mesh";
+            http: "http";
+            ws: "ws";
+        }>;
+        procedure: z.ZodString;
+        userAgent: z.ZodString;
+        ip: z.ZodString;
+        principal: z.ZodString;
+        calls: z.ZodNumber;
+        subscriptions: z.ZodNumber;
+        perMin: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * The census as an operator sees it.
+ *
+ * `persisted` is the honest answer to "will this survive the restart I am
+ * about to do": the arm deadline is written to `system-settings` so a window
+ * armed now can measure the NEXT boot, and a write that failed must not look
+ * like one that succeeded.
+ */
+declare const RequestCensusStatusSchema: z.ZodObject<{
+    armed: z.ZodBoolean;
+    elapsedMs: z.ZodNumber;
+    windowMs: z.ZodNumber;
+    armedUntilMs: z.ZodNumber;
+    httpRequests: z.ZodNumber;
+    batchedRequests: z.ZodNumber;
+    procedureCalls: z.ZodNumber;
+    planes: z.ZodObject<{
+        http: z.ZodNumber;
+        ws: z.ZodNumber;
+        mesh: z.ZodNumber;
+        unknown: z.ZodNumber;
+    }, z.core.$strip>;
+    planesExplainTotal: z.ZodBoolean;
+    wsConnections: z.ZodNumber;
+    wsMessages: z.ZodNumber;
+    subscriptions: z.ZodNumber;
+    subscriptionStops: z.ZodNumber;
+    distinctGroups: z.ZodNumber;
+    unattributedCalls: z.ZodNumber;
+    procedures: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        procedure: z.ZodString;
+        calls: z.ZodNumber;
+        planes: z.ZodObject<{
+            http: z.ZodNumber;
+            ws: z.ZodNumber;
+            mesh: z.ZodNumber;
+            unknown: z.ZodNumber;
+        }, z.core.$strip>;
+        subscriptions: z.ZodNumber;
+        perMin: z.ZodNumber;
+    }, z.core.$strip>>>;
+    groups: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        plane: z.ZodEnum<{
+            unknown: "unknown";
+            mesh: "mesh";
+            http: "http";
+            ws: "ws";
+        }>;
+        procedure: z.ZodString;
+        userAgent: z.ZodString;
+        ip: z.ZodString;
+        principal: z.ZodString;
+        calls: z.ZodNumber;
+        subscriptions: z.ZodNumber;
+        perMin: z.ZodNumber;
+    }, z.core.$strip>>>;
+    persisted: z.ZodBoolean;
+}, z.core.$strip>;
+/** Severity vocabulary. Mirrors `LogLevel` in `interfaces/logging.ts`. */
+declare const LogLevelSchema: z.ZodEnum<{
+    error: "error";
+    debug: "debug";
+    info: "info";
+    warn: "warn";
+}>;
+/**
+ * The diagnostics that can be ARMED for a window. Exactly one today.
+ *
+ * A diagnostic is anything whose cost is only worth paying while a question is
+ * open. It never persists as a boolean: see {@link DiagnosticWindowSchema}.
+ */
+declare const DiagnosticIdSchema: z.ZodEnum<{
+    "request-census": "request-census";
+}>;
+/**
+ * The layers of the level hierarchy, general → specific. The most specific
+ * layer that carries an explicit value wins.
+ *
+ * `component` is DECLARED and not yet resolvable: the per-component channels
+ * are a later slice of the same plan, and a `levelSource` enum that has to
+ * grow later would force every consumer of this document to change with it.
+ * Nothing returns `component` today.
+ */
+declare const LoggingScopeKindSchema: z.ZodEnum<{
+    node: "node";
+    cluster: "cluster";
+    component: "component";
+}>;
+/** Where an effective level came from. `default` = nothing is set anywhere. */
+declare const LoggingLevelSourceSchema: z.ZodEnum<{
+    default: "default";
+    node: "node";
+    cluster: "cluster";
+    component: "component";
+}>;
+/**
+ * One layer of the hierarchy as it actually STANDS.
+ *
+ * `level: null` is the whole reason this array is returned: it is the
+ * difference between "this node is at `info` because I decided it" and
+ * "...because it inherits". An operator who clears an override believing they
+ * are clearing an inherited value has been handed the same defect as the two
+ * contradicting knobs this document exists to remove, moved one floor up.
+ */
+declare const LoggingLevelLayerSchema: z.ZodObject<{
+    scope: z.ZodEnum<{
+        node: "node";
+        cluster: "cluster";
+        component: "component";
+    }>;
+    nodeId: z.ZodNullable<z.ZodString>;
+    level: z.ZodNullable<z.ZodEnum<{
+        error: "error";
+        debug: "debug";
+        info: "info";
+        warn: "warn";
+    }>>;
+}, z.core.$strip>;
+/** What a line is judged against, and WHICH layer decided it. */
+declare const LoggingEffectiveSchema: z.ZodObject<{
+    level: z.ZodEnum<{
+        error: "error";
+        debug: "debug";
+        info: "info";
+        warn: "warn";
+    }>;
+    levelSource: z.ZodEnum<{
+        default: "default";
+        node: "node";
+        cluster: "cluster";
+        component: "component";
+    }>;
+}, z.core.$strip>;
+/** Every layer, general → specific. Never collapsed into the effective value. */
+declare const LoggingExplicitSchema: z.ZodObject<{
+    layers: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        scope: z.ZodEnum<{
+            node: "node";
+            cluster: "cluster";
+            component: "component";
+        }>;
+        nodeId: z.ZodNullable<z.ZodString>;
+        level: z.ZodNullable<z.ZodEnum<{
+            error: "error";
+            debug: "debug";
+            info: "info";
+            warn: "warn";
+        }>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * An armed diagnostic, with its DEADLINE.
+ *
+ * The shape of ADR-0244: what is stored is a deadline and never a flag, so a
+ * diagnostic somebody forgot expires by itself, and a boot-window measurement
+ * survives the restart it exists to measure. `remainingMs` is 0 whenever
+ * `armed` is false — a window is never reported as slightly expired.
+ */
+declare const DiagnosticWindowSchema: z.ZodObject<{
+    id: z.ZodEnum<{
+        "request-census": "request-census";
+    }>;
+    armed: z.ZodBoolean;
+    armedUntilMs: z.ZodNumber;
+    remainingMs: z.ZodNumber;
+    persisted: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * `armMs: 0` DISARMS. Any positive value arms for that long, clamped by the
+ * server — there is no maximum here on purpose: a bound repeated in a schema
+ * is a second knob that disagrees with the first the day one of them moves.
+ */
+declare const DiagnosticWindowPatchSchema: z.ZodObject<{
+    id: z.ZodEnum<{
+        "request-census": "request-census";
+    }>;
+    armMs: z.ZodNumber;
+    reportEveryMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * A PATCH, and patches MERGE.
+ *
+ * A field absent from the patch is left exactly as it was — arming a
+ * diagnostic never resets a level, and setting a level never disarms a window.
+ * The provider must not reconstruct the document as `{ ...snapshot, ...patch }`:
+ * `setAll` already merges, and rebuilding the object is how an absent field
+ * turns into an erased one.
+ */
+declare const LoggingSettingsPatchSchema: z.ZodObject<{
+    level: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        error: "error";
+        debug: "debug";
+        info: "info";
+        warn: "warn";
+    }>>>;
+    diagnostics: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodEnum<{
+            "request-census": "request-census";
+        }>;
+        armMs: z.ZodNumber;
+        reportEveryMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+/**
+ * Which LAYER of the hierarchy is addressed. Absent = the cluster layer.
+ *
+ * Deliberately NOT called `nodeId`: that key is reserved on every cap method
+ * input — the generated router strips it and uses it to resolve the PROVIDER
+ * on that node (`resolveProvider(cap, nodeId, …)`). A document about
+ * `agent-1` addressed as `nodeId` would be forwarded to agent-1 and answered
+ * by an agent that holds no cluster document at all. The hub is the single
+ * authority over the whole hierarchy and answers for every layer, so the
+ * layer selector needs a name the transport does not already own.
+ */
+declare const GetLoggingSettingsInputSchema: z.ZodObject<{
+    scopeNodeId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const SetLoggingSettingsInputSchema: z.ZodObject<{
+    scopeNodeId: z.ZodOptional<z.ZodString>;
+    patch: z.ZodObject<{
+        level: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            error: "error";
+            debug: "debug";
+            info: "info";
+            warn: "warn";
+        }>>>;
+        diagnostics: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodEnum<{
+                "request-census": "request-census";
+            }>;
+            armMs: z.ZodNumber;
+            reportEveryMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * The whole document, as read and as returned after every write.
+ *
+ * `persisted: false` means the settings store could not be read or written.
+ * The in-memory mirror still governs behaviour and is unchanged by the
+ * failure — a read that fails neither switches a level nor disarms a window
+ * (D49) — but the operator is told that what they are looking at would not
+ * survive a restart.
+ */
+declare const LoggingSettingsStateSchema: z.ZodObject<{
+    scopeNodeId: z.ZodNullable<z.ZodString>;
+    effective: z.ZodObject<{
+        level: z.ZodEnum<{
+            error: "error";
+            debug: "debug";
+            info: "info";
+            warn: "warn";
+        }>;
+        levelSource: z.ZodEnum<{
+            default: "default";
+            node: "node";
+            cluster: "cluster";
+            component: "component";
+        }>;
+    }, z.core.$strip>;
+    explicit: z.ZodObject<{
+        layers: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            scope: z.ZodEnum<{
+                node: "node";
+                cluster: "cluster";
+                component: "component";
+            }>;
+            nodeId: z.ZodNullable<z.ZodString>;
+            level: z.ZodNullable<z.ZodEnum<{
+                error: "error";
+                debug: "debug";
+                info: "info";
+                warn: "warn";
+            }>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    activeWindows: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodEnum<{
+            "request-census": "request-census";
+        }>;
+        armed: z.ZodBoolean;
+        armedUntilMs: z.ZodNumber;
+        remainingMs: z.ZodNumber;
+        persisted: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    persisted: z.ZodBoolean;
+}, z.core.$strip>;
 export declare const systemCapability: {
     readonly name: "system";
     readonly scope: "system";
@@ -204,6 +622,187 @@ export declare const systemCapability: {
             derivationAttemptedAt: z.ZodNullable<z.ZodNumber>;
             derivationError: z.ZodNullable<z.ZodString>;
         }, z.core.$strip>, "mutation">;
+        /**
+         * Read the HTTP request census - which caller, from which address, with
+         * which user-agent, invoked which tRPC procedure, and how often.
+         *
+         * Reading NEVER re-arms: re-arming clears the counts, which would throw
+         * away exactly the numbers being asked for. A closed window may be read as
+         * many times as the operator likes and always describes the same window.
+         *
+         * Admin-only: the rows carry source addresses and principal names.
+         */
+        readonly getRequestCensus: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            armed: z.ZodBoolean;
+            elapsedMs: z.ZodNumber;
+            windowMs: z.ZodNumber;
+            armedUntilMs: z.ZodNumber;
+            httpRequests: z.ZodNumber;
+            batchedRequests: z.ZodNumber;
+            procedureCalls: z.ZodNumber;
+            planes: z.ZodObject<{
+                http: z.ZodNumber;
+                ws: z.ZodNumber;
+                mesh: z.ZodNumber;
+                unknown: z.ZodNumber;
+            }, z.core.$strip>;
+            planesExplainTotal: z.ZodBoolean;
+            wsConnections: z.ZodNumber;
+            wsMessages: z.ZodNumber;
+            subscriptions: z.ZodNumber;
+            subscriptionStops: z.ZodNumber;
+            distinctGroups: z.ZodNumber;
+            unattributedCalls: z.ZodNumber;
+            procedures: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                procedure: z.ZodString;
+                calls: z.ZodNumber;
+                planes: z.ZodObject<{
+                    http: z.ZodNumber;
+                    ws: z.ZodNumber;
+                    mesh: z.ZodNumber;
+                    unknown: z.ZodNumber;
+                }, z.core.$strip>;
+                subscriptions: z.ZodNumber;
+                perMin: z.ZodNumber;
+            }, z.core.$strip>>>;
+            groups: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                plane: z.ZodEnum<{
+                    unknown: "unknown";
+                    mesh: "mesh";
+                    http: "http";
+                    ws: "ws";
+                }>;
+                procedure: z.ZodString;
+                userAgent: z.ZodString;
+                ip: z.ZodString;
+                principal: z.ZodString;
+                calls: z.ZodNumber;
+                subscriptions: z.ZodNumber;
+                perMin: z.ZodNumber;
+            }, z.core.$strip>>>;
+            persisted: z.ZodBoolean;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * The logging settings document — levels and armed diagnostics — resolved
+         * for `nodeId`, or for the cluster when `nodeId` is absent.
+         *
+         * Returns BOTH `effective` and `explicit`. See
+         * {@link LoggingLevelLayerSchema} for why collapsing them is the defect.
+         */
+        readonly getLoggingSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            scopeNodeId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            scopeNodeId: z.ZodNullable<z.ZodString>;
+            effective: z.ZodObject<{
+                level: z.ZodEnum<{
+                    error: "error";
+                    debug: "debug";
+                    info: "info";
+                    warn: "warn";
+                }>;
+                levelSource: z.ZodEnum<{
+                    default: "default";
+                    node: "node";
+                    cluster: "cluster";
+                    component: "component";
+                }>;
+            }, z.core.$strip>;
+            explicit: z.ZodObject<{
+                layers: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    scope: z.ZodEnum<{
+                        node: "node";
+                        cluster: "cluster";
+                        component: "component";
+                    }>;
+                    nodeId: z.ZodNullable<z.ZodString>;
+                    level: z.ZodNullable<z.ZodEnum<{
+                        error: "error";
+                        debug: "debug";
+                        info: "info";
+                        warn: "warn";
+                    }>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>;
+            activeWindows: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                id: z.ZodEnum<{
+                    "request-census": "request-census";
+                }>;
+                armed: z.ZodBoolean;
+                armedUntilMs: z.ZodNumber;
+                remainingMs: z.ZodNumber;
+                persisted: z.ZodBoolean;
+            }, z.core.$strip>>>;
+            persisted: z.ZodBoolean;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Write the logging settings document. The ONLY write authority over log
+         * levels and diagnostic windows — arming the request census went through
+         * `system.setRequestCensus` until 2026-08-27 and no longer does, because
+         * two writes that disagree about the same window is exactly the defect
+         * this document exists to remove (D245).
+         *
+         * The patch MERGES: see {@link LoggingSettingsPatchSchema}.
+         */
+        readonly setLoggingSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            scopeNodeId: z.ZodOptional<z.ZodString>;
+            patch: z.ZodObject<{
+                level: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                    error: "error";
+                    debug: "debug";
+                    info: "info";
+                    warn: "warn";
+                }>>>;
+                diagnostics: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    id: z.ZodEnum<{
+                        "request-census": "request-census";
+                    }>;
+                    armMs: z.ZodNumber;
+                    reportEveryMs: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            scopeNodeId: z.ZodNullable<z.ZodString>;
+            effective: z.ZodObject<{
+                level: z.ZodEnum<{
+                    error: "error";
+                    debug: "debug";
+                    info: "info";
+                    warn: "warn";
+                }>;
+                levelSource: z.ZodEnum<{
+                    default: "default";
+                    node: "node";
+                    cluster: "cluster";
+                    component: "component";
+                }>;
+            }, z.core.$strip>;
+            explicit: z.ZodObject<{
+                layers: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    scope: z.ZodEnum<{
+                        node: "node";
+                        cluster: "cluster";
+                        component: "component";
+                    }>;
+                    nodeId: z.ZodNullable<z.ZodString>;
+                    level: z.ZodNullable<z.ZodEnum<{
+                        error: "error";
+                        debug: "debug";
+                        info: "info";
+                        warn: "warn";
+                    }>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>;
+            activeWindows: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                id: z.ZodEnum<{
+                    "request-census": "request-census";
+                }>;
+                armed: z.ZodBoolean;
+                armedUntilMs: z.ZodNumber;
+                remainingMs: z.ZodNumber;
+                persisted: z.ZodBoolean;
+            }, z.core.$strip>>>;
+            persisted: z.ZodBoolean;
+        }, z.core.$strip>, "mutation">;
     };
     /** BIG PLAN 2: declarative mount hint — read by `@camstack/system` `buildCapRouters`. */
     readonly mount: {
@@ -211,8 +810,26 @@ export declare const systemCapability: {
     };
 };
 export type ISystemProvider = InferProvider<typeof systemCapability>;
+export type RequestCensusGroup = z.infer<typeof RequestCensusGroupSchema>;
+export type RequestCensusProcedure = z.infer<typeof RequestCensusProcedureSchema>;
+export type RequestCensusSnapshot = z.infer<typeof RequestCensusSnapshotSchema>;
+export type RequestCensusStatus = z.infer<typeof RequestCensusStatusSchema>;
+export type TransportPlane = z.infer<typeof TransportPlaneSchema>;
+export type TransportPlaneCounts = z.infer<typeof TransportPlaneCountsSchema>;
+export type DiagnosticId = z.infer<typeof DiagnosticIdSchema>;
+export type DiagnosticWindow = z.infer<typeof DiagnosticWindowSchema>;
+export type DiagnosticWindowPatch = z.infer<typeof DiagnosticWindowPatchSchema>;
+export type GetLoggingSettingsInput = z.infer<typeof GetLoggingSettingsInputSchema>;
+export type LoggingEffective = z.infer<typeof LoggingEffectiveSchema>;
+export type LoggingExplicit = z.infer<typeof LoggingExplicitSchema>;
+export type LoggingLevelLayer = z.infer<typeof LoggingLevelLayerSchema>;
+export type LoggingLevelSource = z.infer<typeof LoggingLevelSourceSchema>;
+export type LoggingScopeKind = z.infer<typeof LoggingScopeKindSchema>;
+export type LoggingSettingsPatch = z.infer<typeof LoggingSettingsPatchSchema>;
+export type LoggingSettingsState = z.infer<typeof LoggingSettingsStateSchema>;
+export type SetLoggingSettingsInput = z.infer<typeof SetLoggingSettingsInputSchema>;
 export type SiteLocation = z.infer<typeof SiteLocationSchema>;
 export type SiteLocationSource = z.infer<typeof SiteLocationSourceSchema>;
 export type SiteLocationStatus = z.infer<typeof SiteLocationStatusSchema>;
 export type SetSiteLocationInput = z.infer<typeof SetSiteLocationInputSchema>;
-export { FeatureManifestSchema, HealthStatusSchema, NetworkAddressSchema, SetSiteLocationInputSchema, SiteLocationSchema, SiteLocationSourceSchema, SiteLocationStatusSchema, };
+export { DiagnosticIdSchema, DiagnosticWindowPatchSchema, DiagnosticWindowSchema, FeatureManifestSchema, GetLoggingSettingsInputSchema, HealthStatusSchema, LoggingEffectiveSchema, LoggingExplicitSchema, LoggingLevelLayerSchema, LoggingLevelSourceSchema, LoggingScopeKindSchema, LoggingSettingsPatchSchema, LoggingSettingsStateSchema, LogLevelSchema, NetworkAddressSchema, RequestCensusGroupSchema, RequestCensusProcedureSchema, RequestCensusSnapshotSchema, RequestCensusStatusSchema, SetLoggingSettingsInputSchema, SetSiteLocationInputSchema, SiteLocationSchema, SiteLocationSourceSchema, SiteLocationStatusSchema, TransportPlaneCountsSchema, TransportPlaneSchema, };

package/dist/catalogs/index.d.ts

@@ -1,3 +1,4 @@
 export * from './coco-classmap.js';
+export * from './sensor-active-state.js';
 export * from './audio-classmap.js';
 export * from './event-taxonomy.js';