@camstack/types 1.2.112 → 1.2.113

package/dist/capabilities/face-gallery.cap.d.ts

@@ -42,6 +42,44 @@ declare const FaceInfoSchema: z.ZodObject<{
     suggestedMatchScore: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type FaceInfo = z.infer<typeof FaceInfoSchema>;
+/**
+ * What a `listRecentFaces` page is ORDERED BY.
+ *
+ *  - `timestamp` — when the face was seen. The historical (and default) order.
+ *  - `suggestionConfidence` — {@link FaceInfo.suggestedMatchScore}, the peak
+ *    cosine of the face's SUGGESTED identity. This is the "review by certainty"
+ *    order: it puts the suggestions an operator can confirm with one tap at the
+ *    top, and it is the reason this enum exists — a client that ranked a capped
+ *    page client-side was ranking the newest N, never the most certain N.
+ *
+ * A row with NO suggestion (`suggestedMatchScore` absent — a legacy row, an
+ * auto-assigned face, or a face below the suggestion band) has no certainty to
+ * compare. Under `suggestionConfidence` it sorts **LAST, in BOTH directions**
+ * — flipping the direction reorders the rows that HAVE a certainty and never
+ * floods the page with the ones that do not. `addon-post-analysis`'s
+ * `store/face-sort.ts` is the single implementation, tiebreaks newest-first
+ * then by faceId, and is what makes this a total order instead of the
+ * backend's NULL-collation accident.
+ */
+declare const FaceSortFieldEnum: z.ZodEnum<{
+    timestamp: "timestamp";
+    suggestionConfidence: "suggestionConfidence";
+}>;
+export type FaceSortField = z.infer<typeof FaceSortFieldEnum>;
+declare const FaceSortDirectionEnum: z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+}>;
+export type FaceSortDirection = z.infer<typeof FaceSortDirectionEnum>;
+/** One suggested group of look-alike UNASSIGNED faces. Ids only — an embedding
+ *  never leaves the server. */
+declare const FaceClusterSchema: z.ZodObject<{
+    faceIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    representativeFaceId: z.ZodString;
+    size: z.ZodNumber;
+    cohesion: z.ZodNumber;
+}, z.core.$strip>;
+export type FaceCluster = z.infer<typeof FaceClusterSchema>;
 export declare const faceGalleryCapability: {
     readonly name: "face-gallery";
     readonly scope: "system";
@@ -90,6 +128,7 @@ export declare const faceGalleryCapability: {
         }, z.core.$strip>, z.ZodVoid, "mutation">;
         readonly listRecentFaces: import("./capability-definition.js").CapabilityMethodSchema<z.ZodOptional<z.ZodObject<{
             deviceId: z.ZodOptional<z.ZodNumber>;
+            deviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
             limit: z.ZodOptional<z.ZodNumber>;
             filter: z.ZodOptional<z.ZodEnum<{
                 all: "all";
@@ -97,6 +136,16 @@ export declare const faceGalleryCapability: {
                 recognized: "recognized";
                 identified: "identified";
             }>>;
+            since: z.ZodOptional<z.ZodNumber>;
+            until: z.ZodOptional<z.ZodNumber>;
+            sortBy: z.ZodOptional<z.ZodEnum<{
+                timestamp: "timestamp";
+                suggestionConfidence: "suggestionConfidence";
+            }>>;
+            sortDirection: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
             includeCrops: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             faceId: z.ZodString;
@@ -185,7 +234,9 @@ export declare const faceGalleryCapability: {
         readonly suggestFaceClusters: import("./capability-definition.js").CapabilityMethodSchema<z.ZodOptional<z.ZodObject<{
             threshold: z.ZodOptional<z.ZodNumber>;
             minClusterSize: z.ZodOptional<z.ZodNumber>;
+            maxClusters: z.ZodOptional<z.ZodNumber>;
             limit: z.ZodOptional<z.ZodNumber>;
+            maxFacesScanned: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             faceIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
             representativeFaceId: z.ZodString;
@@ -195,4 +246,13 @@ export declare const faceGalleryCapability: {
     };
 };
 export type IFaceGalleryProvider = InferProvider<typeof faceGalleryCapability>;
+/**
+ * The inputs, as the PROVIDER sees them.
+ *
+ * Named so an implementation can annotate its methods without re-typing the
+ * shape (`z.infer`, never a hand copy — a duplicated input shape is how a new
+ * field arrives at the router and is dropped by the provider).
+ */
+export type ListRecentFacesInput = z.infer<typeof faceGalleryCapability.methods.listRecentFaces.input>;
+export type SuggestFaceClustersInput = z.infer<typeof faceGalleryCapability.methods.suggestFaceClusters.input>;
 export {};

package/dist/capabilities/index.d.ts

@@ -142,7 +142,7 @@ export { type DoorbellPressEvent, DoorbellPressEventSchema, type DoorbellStatus,
 export { type EnumSensorDateTimeFormat, EnumSensorDateTimeFormatSchema, type EnumSensorStatus, EnumSensorStatusSchema, enumSensorCapability, type IEnumSensorProvider, } from './enum-sensor.cap.js';
 export { type EventEmitterStatus, EventEmitterStatusSchema, type EventFire, EventFireSchema, eventEmitterCapability, type IEventEmitterProvider, } from './event-emitter.cap.js';
 export { EventItemSchema, eventsCapability, type IEventsProvider } from './events.cap.js';
-export { type FaceInfo, faceGalleryCapability, type Identity, type IdentitySampleInfo, type IFaceGalleryProvider, } from './face-gallery.cap.js';
+export { type FaceCluster, type FaceInfo, type FaceSortDirection, type FaceSortField, faceGalleryCapability, type Identity, type IdentitySampleInfo, type IFaceGalleryProvider, type ListRecentFacesInput, type SuggestFaceClustersInput, } from './face-gallery.cap.js';
 export { type FanControlStatus, FanControlStatusSchema, type FanDirection, FanDirectionSchema, fanControlCapability, type IFanControlProvider, } from './fan-control.cap.js';
 export { type FeatureProbeStatus, FeatureProbeStatusSchema, featureProbeCapability, type IFeatureProbeProvider, } from './feature-probe.cap.js';
 export { type FloodStatus, FloodStatusSchema, floodCapability, type IFloodProvider, } from './flood.cap.js';
@@ -189,7 +189,7 @@ export { type CamStreamDescriptor, CamStreamDescriptorSchema, type IStreamCatalo
 export { type IStreamParamsProvider, type StreamParamsOptions, StreamParamsOptionsSchema, type StreamParamsStatus, StreamParamsStatusSchema, type StreamProfile, StreamProfileConfigSchema, StreamProfileOptionsSchema, type StreamProfilePatch, StreamProfilePatchSchema, StreamProfileSchema, streamParamsCapability, } from './stream-params.cap.js';
 export { buildStreamParamsConfigSchema, parseStreamParamsFormPatch, STREAM_PROFILE_META, type StreamProfileMeta, } from './stream-params-config-schema.js';
 export { type ISwitchProvider, type SwitchStatus, SwitchStatusSchema, switchCapability, } from './switch.cap.js';
-export { FeatureManifestSchema, HealthStatusSchema, type ISystemProvider, NetworkAddressSchema, type SetSiteLocationInput, SetSiteLocationInputSchema, type SiteLocation, SiteLocationSchema, type SiteLocationSource, SiteLocationSourceSchema, type SiteLocationStatus, SiteLocationStatusSchema, systemCapability, } from './system.cap.js';
+export { type DiagnosticId, DiagnosticIdSchema, type DiagnosticWindow, type DiagnosticWindowPatch, DiagnosticWindowPatchSchema, DiagnosticWindowSchema, FeatureManifestSchema, type GetLoggingSettingsInput, GetLoggingSettingsInputSchema, HealthStatusSchema, type ISystemProvider, type LoggingEffective, LoggingEffectiveSchema, type LoggingExplicit, LoggingExplicitSchema, type LoggingLevelLayer, LoggingLevelLayerSchema, type LoggingLevelSource, LoggingLevelSourceSchema, type LoggingScopeKind, LoggingScopeKindSchema, type LoggingSettingsPatch, LoggingSettingsPatchSchema, type LoggingSettingsState, LoggingSettingsStateSchema, NetworkAddressSchema, type RequestCensusGroup, RequestCensusGroupSchema, type RequestCensusProcedure, RequestCensusProcedureSchema, type RequestCensusSnapshot, RequestCensusSnapshotSchema, type RequestCensusStatus, RequestCensusStatusSchema, type SetLoggingSettingsInput, SetLoggingSettingsInputSchema, type SetSiteLocationInput, SetSiteLocationInputSchema, type SiteLocation, SiteLocationSchema, type SiteLocationSource, SiteLocationSourceSchema, type SiteLocationStatus, SiteLocationStatusSchema, systemCapability, } from './system.cap.js';
 export { type ITamperProvider, type TamperStatus, TamperStatusSchema, tamperCapability, } from './tamper.cap.js';
 export { type ITemperatureSensorProvider, type TemperatureSensorStatus, TemperatureSensorStatusSchema, temperatureSensorCapability, } from './temperature-sensor.cap.js';
 export { type IToastProvider, ToastSchema, toastCapability } from './toast.cap.js';

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

@@ -327,6 +327,12 @@ export declare const recordingCapability: {
                 triggers: z.ZodOptional<z.ZodObject<{
                     motion: z.ZodOptional<z.ZodBoolean>;
                     audioThresholdDbfs: z.ZodOptional<z.ZodNumber>;
+                    objectClasses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        person: "person";
+                        vehicle: "vehicle";
+                        animal: "animal";
+                    }>>>;
+                    sensorDeviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 }, z.core.$strip>>;
                 preBufferSec: z.ZodOptional<z.ZodNumber>;
                 postBufferSec: z.ZodOptional<z.ZodNumber>;
@@ -422,6 +428,12 @@ export declare const recordingCapability: {
                     triggers: z.ZodOptional<z.ZodObject<{
                         motion: z.ZodOptional<z.ZodBoolean>;
                         audioThresholdDbfs: z.ZodOptional<z.ZodNumber>;
+                        objectClasses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                            person: "person";
+                            vehicle: "vehicle";
+                            animal: "animal";
+                        }>>>;
+                        sensorDeviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                     }, z.core.$strip>>;
                     preBufferSec: z.ZodOptional<z.ZodNumber>;
                     postBufferSec: z.ZodOptional<z.ZodNumber>;
@@ -455,6 +467,12 @@ export declare const recordingCapability: {
                 triggers: z.ZodOptional<z.ZodObject<{
                     motion: z.ZodOptional<z.ZodBoolean>;
                     audioThresholdDbfs: z.ZodOptional<z.ZodNumber>;
+                    objectClasses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        person: "person";
+                        vehicle: "vehicle";
+                        animal: "animal";
+                    }>>>;
+                    sensorDeviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 }, z.core.$strip>>;
                 preBufferSec: z.ZodOptional<z.ZodNumber>;
                 postBufferSec: z.ZodOptional<z.ZodNumber>;

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

@@ -102,6 +102,321 @@ declare const SetSiteLocationInputSchema: z.ZodNullable<z.ZodObject<{
     latitude: z.ZodNumber;
     longitude: z.ZodNumber;
 }, z.core.$strip>>;
+/**
+ * One `(procedure, user-agent, ip, principal)` tuple of the HTTP request
+ * 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.
+ */
+declare const RequestCensusGroupSchema: z.ZodObject<{
+    procedure: z.ZodString;
+    userAgent: z.ZodString;
+    ip: z.ZodString;
+    principal: z.ZodString;
+    calls: 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;
+    perMin: z.ZodNumber;
+}, z.core.$strip>;
+/** What one armed window measured. Mirrors `HttpRequestCensus.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;
+    wsConnections: z.ZodNumber;
+    distinctGroups: z.ZodNumber;
+    unattributedCalls: z.ZodNumber;
+    procedures: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        procedure: z.ZodString;
+        calls: z.ZodNumber;
+        perMin: z.ZodNumber;
+    }, z.core.$strip>>>;
+    groups: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        procedure: z.ZodString;
+        userAgent: z.ZodString;
+        ip: z.ZodString;
+        principal: z.ZodString;
+        calls: 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;
+    wsConnections: z.ZodNumber;
+    distinctGroups: z.ZodNumber;
+    unattributedCalls: z.ZodNumber;
+    procedures: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        procedure: z.ZodString;
+        calls: z.ZodNumber;
+        perMin: z.ZodNumber;
+    }, z.core.$strip>>>;
+    groups: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        procedure: z.ZodString;
+        userAgent: z.ZodString;
+        ip: z.ZodString;
+        principal: z.ZodString;
+        calls: 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 +519,163 @@ 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;
+            wsConnections: z.ZodNumber;
+            distinctGroups: z.ZodNumber;
+            unattributedCalls: z.ZodNumber;
+            procedures: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                procedure: z.ZodString;
+                calls: z.ZodNumber;
+                perMin: z.ZodNumber;
+            }, z.core.$strip>>>;
+            groups: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                procedure: z.ZodString;
+                userAgent: z.ZodString;
+                ip: z.ZodString;
+                principal: z.ZodString;
+                calls: 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 +683,24 @@ 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 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, LogLevelSchema, LoggingEffectiveSchema, LoggingExplicitSchema, LoggingLevelLayerSchema, LoggingLevelSourceSchema, LoggingScopeKindSchema, LoggingSettingsPatchSchema, LoggingSettingsStateSchema, NetworkAddressSchema, RequestCensusGroupSchema, RequestCensusProcedureSchema, RequestCensusSnapshotSchema, RequestCensusStatusSchema, SetLoggingSettingsInputSchema, SetSiteLocationInputSchema, SiteLocationSchema, SiteLocationSourceSchema, SiteLocationStatusSchema, };

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';