@camstack/types 0.1.14 → 0.1.16

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

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+declare const RegisteredStreamSchema: z.ZodObject<{
+    streamId: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    codec: z.ZodString;
+    type: z.ZodEnum<{
+        audio: "audio";
+        video: "video";
+    }>;
+    sourceUrl: z.ZodString;
+}, z.core.$strip>;
+declare const ExposedResourceSchema: z.ZodObject<{
+    streamId: z.ZodString;
+    format: z.ZodString;
+    value: z.ZodString;
+}, z.core.$strip>;
+export declare const restreamerCapability: {
+    readonly name: "restreamer";
+    readonly scope: "system";
+    readonly mode: "collection";
+    readonly internal: true;
+    readonly methods: {
+        readonly registerDevice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            streams: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                streamId: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+                codec: z.ZodString;
+                type: z.ZodEnum<{
+                    audio: "audio";
+                    video: "video";
+                }>;
+                sourceUrl: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly unregisterDevice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly getExposedResources: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            streamId: z.ZodString;
+            format: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IRestreamerProvider = InferProvider<typeof restreamerCapability>;
+export { RegisteredStreamSchema, ExposedResourceSchema };
+//# sourceMappingURL=restreamer.cap.d.ts.map

package/dist/capabilities/restreamer.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restreamer.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/restreamer.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG,QAAA,MAAM,sBAAsB;;;;;;;;;iBAM1B,CAAA;AAEF,QAAA,MAAM,qBAAqB;;;;iBAIzB,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiBQ,CAAA;AAEzC,MAAM,MAAM,mBAAmB,GAAG,aAAa,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAE5E,OAAO,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,CAAA"}

package/dist/capabilities/schemas/detection-shared.d.ts

@@ -0,0 +1,63 @@
+/** Shared Zod schemas used across detection capabilities. */
+import { z } from 'zod';
+/**
+ * Canonical frame-format enum mirrored on `FrameFormat` in
+ * `packages/types/src/types/io.ts`. Kept inline (vs imported) so the
+ * Zod runtime schema and TypeScript type stay in sync at the call site
+ * — adding a new format requires changing both this enum and the
+ * `FrameFormat` type alias together.
+ */
+export declare const FrameFormatSchema: z.ZodEnum<{
+    jpeg: "jpeg";
+    rgb: "rgb";
+    bgr: "bgr";
+    yuv420: "yuv420";
+    gray: "gray";
+}>;
+export declare const FrameInputSchema: z.ZodObject<{
+    data: z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
+    format: z.ZodEnum<{
+        jpeg: "jpeg";
+        rgb: "rgb";
+        bgr: "bgr";
+        yuv420: "yuv420";
+        gray: "gray";
+    }>;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export declare const BoundingBoxSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    w: z.ZodNumber;
+    h: z.ZodNumber;
+}, z.core.$strip>;
+export declare const SpatialDetectionSchema: z.ZodObject<{
+    class: z.ZodString;
+    originalClass: z.ZodString;
+    score: z.ZodNumber;
+    bbox: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        w: z.ZodNumber;
+        h: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const AudioChunkInputSchema: z.ZodObject<{
+    data: z.ZodCustom<Float32Array<ArrayBuffer>, Float32Array<ArrayBuffer>>;
+    sampleRate: z.ZodNumber;
+    channels: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    deviceId: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const AudioLevelSchema: z.ZodObject<{
+    rms: z.ZodNumber;
+    dbfs: z.ZodNumber;
+}, z.core.$strip>;
+export declare const AudioClassificationLabelSchema: z.ZodObject<{
+    className: z.ZodString;
+    originalClass: z.ZodOptional<z.ZodString>;
+    score: z.ZodNumber;
+}, z.core.$strip>;
+//# sourceMappingURL=detection-shared.d.ts.map

package/dist/capabilities/schemas/detection-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detection-shared.d.ts","sourceRoot":"","sources":["../../../src/capabilities/schemas/detection-shared.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAE7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB;;;;;;EAAmD,CAAA;AAEjF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;iBAM3B,CAAA;AAEF,eAAO,MAAM,iBAAiB;;;;;iBAK5B,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;iBAKjC,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;;;;iBAOhC,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;iBAG3B,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;iBAgBzC,CAAA"}

package/dist/capabilities/schemas/orchestrator-metrics.d.ts

@@ -0,0 +1,44 @@
+/** Shared Zod schemas for the runtime pipeline orchestrator metrics. */
+import { z } from 'zod';
+export declare const OrchestratorMetricsSchema: z.ZodObject<{
+    activeCameras: z.ZodNumber;
+    throttledCameras: z.ZodNumber;
+    avgInferenceTimeMs: z.ZodNumber;
+    queueDepth: z.ZodNumber;
+}, z.core.$strip>;
+export declare const CameraMetricsSchema: z.ZodObject<{
+    detectionMode: z.ZodEnum<{
+        disabled: "disabled";
+        "always-on": "always-on";
+        "on-motion": "on-motion";
+    }>;
+    configuredFps: z.ZodNumber;
+    actualFps: z.ZodNumber;
+    queueDepth: z.ZodNumber;
+    avgInferenceTimeMs: z.ZodNumber;
+    droppedFrames: z.ZodNumber;
+    phase: z.ZodEnum<{
+        idle: "idle";
+        watching: "watching";
+        active: "active";
+    }>;
+}, z.core.$strip>;
+export declare const CameraMetricsWithDeviceIdSchema: z.ZodObject<{
+    detectionMode: z.ZodEnum<{
+        disabled: "disabled";
+        "always-on": "always-on";
+        "on-motion": "on-motion";
+    }>;
+    configuredFps: z.ZodNumber;
+    actualFps: z.ZodNumber;
+    queueDepth: z.ZodNumber;
+    avgInferenceTimeMs: z.ZodNumber;
+    droppedFrames: z.ZodNumber;
+    phase: z.ZodEnum<{
+        idle: "idle";
+        watching: "watching";
+        active: "active";
+    }>;
+    deviceId: z.ZodNumber;
+}, z.core.$strip>;
+//# sourceMappingURL=orchestrator-metrics.d.ts.map

package/dist/capabilities/schemas/orchestrator-metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-metrics.d.ts","sourceRoot":"","sources":["../../../src/capabilities/schemas/orchestrator-metrics.ts"],"names":[],"mappings":"AAAA,wEAAwE;AAExE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,yBAAyB;;;;;iBAKpC,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;iBAQ9B,CAAA;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;iBAE1C,CAAA"}

package/dist/capabilities/schemas/streaming-shared.d.ts

@@ -0,0 +1,177 @@
+/** Shared Zod schemas used across streaming capabilities. */
+import { z } from 'zod';
+export declare const CamProfileSchema: z.ZodEnum<{
+    high: "high";
+    mid: "mid";
+    low: "low";
+}>;
+export type CamProfile = z.infer<typeof CamProfileSchema>;
+/** Canonical ordering. Hard-coded; never sorted. */
+export declare const CAM_PROFILE_ORDER: readonly ["high", "mid", "low"];
+export declare const CamStreamKindSchema: z.ZodEnum<{
+    "pull-rtsp": "pull-rtsp";
+    "pull-rtmp": "pull-rtmp";
+    "pull-http": "pull-http";
+    "pull-rfc4571": "pull-rfc4571";
+    "push-annexb": "push-annexb";
+}>;
+export type CamStreamKind = z.infer<typeof CamStreamKindSchema>;
+export declare const CamStreamResolutionSchema: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>;
+export declare const CameraStreamSchema: z.ZodObject<{
+    camStreamId: z.ZodString;
+    deviceId: z.ZodNumber;
+    kind: z.ZodEnum<{
+        "pull-rtsp": "pull-rtsp";
+        "pull-rtmp": "pull-rtmp";
+        "pull-http": "pull-http";
+        "pull-rfc4571": "pull-rfc4571";
+        "push-annexb": "push-annexb";
+    }>;
+    url: z.ZodOptional<z.ZodString>;
+    codec: z.ZodOptional<z.ZodString>;
+    resolution: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>;
+    fps: z.ZodOptional<z.ZodNumber>;
+    label: z.ZodOptional<z.ZodString>;
+    deviceFeatures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    autoEligible: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type CameraStream = z.infer<typeof CameraStreamSchema>;
+export declare const ProfileSlotStatusSchema: z.ZodEnum<{
+    error: "error";
+    streaming: "streaming";
+    idle: "idle";
+    connecting: "connecting";
+    unassigned: "unassigned";
+}>;
+export type ProfileSlotStatus = z.infer<typeof ProfileSlotStatusSchema>;
+export declare const ProfileSlotSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    profile: z.ZodEnum<{
+        high: "high";
+        mid: "mid";
+        low: "low";
+    }>;
+    brokerId: z.ZodString;
+    sourceCamStreamId: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        error: "error";
+        streaming: "streaming";
+        idle: "idle";
+        connecting: "connecting";
+        unassigned: "unassigned";
+    }>;
+    resolution: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>;
+    codec: z.ZodOptional<z.ZodString>;
+    preBufferSec: z.ZodOptional<z.ZodNumber>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ProfileSlot = z.infer<typeof ProfileSlotSchema>;
+/**
+ * Zod schema for StreamSourceEntry — the canonical stream descriptor
+ * exposed by ICameraDevice.getStreamSources() and consumed by the broker.
+ */
+export declare const StreamSourceEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    protocol: z.ZodEnum<{
+        custom: "custom";
+        rtsp: "rtsp";
+        rtmp: "rtmp";
+        webrtc: "webrtc";
+        annexb: "annexb";
+        "http-mjpeg": "http-mjpeg";
+    }>;
+    url: z.ZodOptional<z.ZodString>;
+    resolution: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>>;
+    fps: z.ZodOptional<z.ZodNumber>;
+    bitrate: z.ZodOptional<z.ZodNumber>;
+    codec: z.ZodOptional<z.ZodString>;
+    profileHint: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        mid: "mid";
+        low: "low";
+    }>>;
+}, z.core.$strip>;
+export declare const StreamSourceSchema: z.ZodObject<{
+    type: z.ZodString;
+    url: z.ZodString;
+    videoCodec: z.ZodOptional<z.ZodString>;
+    audioCodec: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+export declare const EncodedPacketSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        audio: "audio";
+        video: "video";
+    }>;
+    data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+    pts: z.ZodNumber;
+    dts: z.ZodNumber;
+    keyframe: z.ZodBoolean;
+    codec: z.ZodString;
+}, z.core.$strip>;
+export declare const DecodedFrameSchema: z.ZodObject<{
+    data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    format: z.ZodEnum<{
+        jpeg: "jpeg";
+        rgb: "rgb";
+        bgr: "bgr";
+        yuv420: "yuv420";
+        gray: "gray";
+    }>;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export declare const BrokerStatusSchema: z.ZodEnum<{
+    error: "error";
+    streaming: "streaming";
+    stopped: "stopped";
+    idle: "idle";
+    connecting: "connecting";
+}>;
+export declare const BrokerStatsSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        error: "error";
+        streaming: "streaming";
+        stopped: "stopped";
+        idle: "idle";
+        connecting: "connecting";
+    }>;
+    inputFps: z.ZodNumber;
+    decodeFps: z.ZodNumber;
+    encodedSubscribers: z.ZodNumber;
+    decodedSubscribers: z.ZodNumber;
+    uptimeMs: z.ZodNumber;
+    bitrateKbps: z.ZodNumber;
+    idrIntervalMs: z.ZodNumber;
+    codec: z.ZodOptional<z.ZodString>;
+    totalBytes: z.ZodNumber;
+    packetCount: z.ZodNumber;
+    rtspClients: z.ZodNumber;
+    pipeClients: z.ZodNumber;
+    preBufferSec: z.ZodNumber;
+    preBufferMs: z.ZodNumber;
+    preBufferPackets: z.ZodNumber;
+    decoderNodeId: z.ZodNullable<z.ZodString>;
+    audio: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        codec: z.ZodString;
+        sampleRate: z.ZodNumber;
+        channels: z.ZodNumber;
+        supported: z.ZodBoolean;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+//# sourceMappingURL=streaming-shared.d.ts.map

package/dist/capabilities/schemas/streaming-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-shared.d.ts","sourceRoot":"","sources":["../../../src/capabilities/schemas/streaming-shared.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAE7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAUvB,eAAO,MAAM,gBAAgB;;;;EAAiC,CAAA;AAC9D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,oDAAoD;AACpD,eAAO,MAAM,iBAAiB,iCAAkC,CAAA;AAiBhE,eAAO,MAAM,mBAAmB;;;;;;EAM9B,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,eAAO,MAAM,yBAAyB;;;iBAGpC,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;iBA2C7B,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAS7D,eAAO,MAAM,uBAAuB;;;;;;EAMlC,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;iBAY5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;iBAUlC,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;iBAM7B,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;iBAO9B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;iBAM7B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;EAAkE,CAAA;AAEjG,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuC5B,CAAA"}

package/dist/capabilities/schemas/zone-rule.d.ts

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+/**
+ * Per-stage gating mode applied to the zones a rule references.
+ *
+ * - `include`: the rule contributes to a **whitelist** for its stage.
+ *   When at least one `include` rule fires for a stage, only entities
+ *   inside one of those zones pass that stage.
+ * - `exclude`: the rule contributes to a **blacklist** for its stage.
+ *   Entities inside one of those zones are dropped at that stage.
+ *
+ * `monitor`-style observation (count without filtering) is not a rule
+ * mode — zones without any matching rule are observed naturally by
+ * `zone-analytics` (live snapshot + history), so an "I just want to
+ * count, not filter" use case needs no rule at all.
+ */
+export declare const ZoneRuleModeEnum: z.ZodEnum<{
+    include: "include";
+    exclude: "exclude";
+}>;
+export type ZoneRuleMode = z.infer<typeof ZoneRuleModeEnum>;
+/**
+ * Per-consumer rule that references existing zones (geometry) and
+ * defines how a specific pipeline stage should treat them. Each
+ * consumer addon owns its own `ZoneRule[]` array in its per-device
+ * settings:
+ *
+ * - `addon-motion-wasm` → `motionZoneRules: ZoneRule[]` (motion stage)
+ * - `addon-detection-pipeline` → `detectionZoneRules: ZoneRule[]` (detection stage)
+ * - future: notification rules, audio gating, etc.
+ *
+ * One rule applies to N zones (`zoneIds[]`) so the operator can
+ * express "ignore motion in ALL of {garden, street}" with a single
+ * rule. `classFilter` narrows the rule to specific object classes —
+ * "drop person detections in the street, but keep cars" is one
+ * `exclude` rule with `classFilter: ['person']`.
+ *
+ * `enabled` is a soft toggle — the operator can keep the rule
+ * configured but inert without deleting it.
+ */
+export declare const ZoneRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    zoneIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    mode: z.ZodEnum<{
+        include: "include";
+        exclude: "exclude";
+    }>;
+    classFilter: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    overlapThreshold: z.ZodOptional<z.ZodNumber>;
+    bboxInclusionPct: z.ZodOptional<z.ZodNumber>;
+    preferMask: z.ZodOptional<z.ZodBoolean>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ZoneRule = z.infer<typeof ZoneRuleSchema>;
+/**
+ * Convenience array schema — used by addon device-settings
+ * contributions and runtime payloads (e.g. `RunnerCameraConfig`).
+ */
+export declare const ZoneRulesArraySchema: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    zoneIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    mode: z.ZodEnum<{
+        include: "include";
+        exclude: "exclude";
+    }>;
+    classFilter: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    overlapThreshold: z.ZodOptional<z.ZodNumber>;
+    bboxInclusionPct: z.ZodOptional<z.ZodNumber>;
+    preferMask: z.ZodOptional<z.ZodBoolean>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>>>;
+export type ZoneRules = z.infer<typeof ZoneRulesArraySchema>;
+//# sourceMappingURL=zone-rule.d.ts.map

package/dist/capabilities/schemas/zone-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zone-rule.d.ts","sourceRoot":"","sources":["../../../src/capabilities/schemas/zone-rule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB;;;EAAiC,CAAA;AAC9D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE3D;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;iBAkDzB,CAAA;AACF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAErD;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;mBAAqC,CAAA;AACtE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

package/dist/capabilities/settings-store.cap.d.ts

@@ -0,0 +1,198 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * Query filter for settings-store collections.
+ */
+declare const QueryFilterSchema: z.ZodObject<{
+    where: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    whereIn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnknown>>>;
+    whereBetween: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodTuple<[z.ZodUnknown, z.ZodUnknown], null>>>;
+    orderBy: z.ZodOptional<z.ZodObject<{
+        field: z.ZodString;
+        direction: z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>;
+    }, z.core.$strip>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/** A single stored record: `{ id, data }`. */
+declare const SettingsRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+/**
+ * Column declaration for a structured (SQL-backed) collection.
+ * SQLite types: TEXT, INTEGER, REAL, JSON (JSON is a compatibility type —
+ * SQLite stores it as TEXT, backend handles serialization).
+ */
+declare const CollectionColumnSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        TEXT: "TEXT";
+        INTEGER: "INTEGER";
+        REAL: "REAL";
+        JSON: "JSON";
+    }>;
+    primaryKey: z.ZodOptional<z.ZodBoolean>;
+    notNull: z.ZodOptional<z.ZodBoolean>;
+    unique: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const CollectionIndexSchema: z.ZodObject<{
+    name: z.ZodString;
+    columns: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    unique: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * settings-store — singleton capability for addon-scoped persistence.
+ *
+ * Every method operates within a `collection`. An optional `namespace`
+ * field provides access to additional data spaces beyond the default
+ * addon settings — useful for business data (events, tracks, faces, etc.).
+ *
+ * Scoping: the implementation prefixes every collection with the calling
+ * addon's ID automatically. Addons never see each other's data.
+ *
+ *   - No namespace (default): `"addon-settings"` → `"<addonId>:addon-settings"`
+ *   - With namespace: `{ namespace: 'events', collection: 'detections' }` →
+ *     `"<addonId>:events:detections"`
+ *
+ * Implemented by `@camstack/core/builtins/sqlite-settings` (SQLite WAL backend).
+ * Addons access it via `ctx.api.settingsStore.*`.
+ */
+export declare const settingsStoreCapability: {
+    readonly name: "settings-store";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        /** Get a single value by key from a collection. */
+        readonly get: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            collection: z.ZodString;
+            key: z.ZodString;
+        }, z.core.$strip>, z.ZodUnknown, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Set a value by key in a collection (upsert). */
+        readonly set: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            collection: z.ZodString;
+            key: z.ZodString;
+            value: z.ZodUnknown;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /** Get all entries matching an optional filter. */
+        readonly query: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            collection: z.ZodString;
+            filter: z.ZodOptional<z.ZodObject<{
+                where: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                whereIn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnknown>>>;
+                whereBetween: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodTuple<[z.ZodUnknown, z.ZodUnknown], null>>>;
+                orderBy: z.ZodOptional<z.ZodObject<{
+                    field: z.ZodString;
+                    direction: z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>;
+                }, z.core.$strip>>;
+                limit: z.ZodOptional<z.ZodNumber>;
+                offset: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Insert a new record. */
+        readonly insert: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            collection: z.ZodString;
+            record: z.ZodObject<{
+                id: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /** Update an existing record by ID. */
+        readonly update: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            collection: z.ZodString;
+            id: z.ZodString;
+            data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /** Delete a record by key/ID. */
+        readonly delete: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            collection: z.ZodString;
+            key: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /** Count entries in a collection, optionally filtered. */
+        readonly count: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            collection: z.ZodString;
+            filter: z.ZodOptional<z.ZodObject<{
+                where: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                whereIn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnknown>>>;
+                whereBetween: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodTuple<[z.ZodUnknown, z.ZodUnknown], null>>>;
+                orderBy: z.ZodOptional<z.ZodObject<{
+                    field: z.ZodString;
+                    direction: z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>;
+                }, z.core.$strip>>;
+                limit: z.ZodOptional<z.ZodNumber>;
+                offset: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodNumber, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Check if a collection is empty. */
+        readonly isEmpty: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            collection: z.ZodString;
+        }, z.core.$strip>, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Declare a typed (SQL-backed) collection with explicit columns +
+         * indexes. Idempotent: re-declaring an existing collection with the
+         * same shape is a no-op; shape changes (new columns, new indexes)
+         * are applied additively. Subsequent `insert` / `update` / `delete`
+         * / `query` calls on this collection use typed columns instead of
+         * JSON-blob storage — `record.data` fields are spread across
+         * columns, `query.filter.where` matches real columns (no
+         * `json_extract` overhead), `orderBy` uses column indexes.
+         *
+         * Addons call this in `onInitialize` before their first read/write.
+         * Collection names should be namespaced by addon (e.g.
+         * `pipeline-analytics:object-events`) to avoid cross-addon
+         * clashes — no automatic prefix is added.
+         */
+        readonly declareCollection: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            collection: z.ZodString;
+            columns: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodEnum<{
+                    TEXT: "TEXT";
+                    INTEGER: "INTEGER";
+                    REAL: "REAL";
+                    JSON: "JSON";
+                }>;
+                primaryKey: z.ZodOptional<z.ZodBoolean>;
+                notNull: z.ZodOptional<z.ZodBoolean>;
+                unique: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+            indexes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                columns: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                unique: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+};
+export type ISettingsStoreProvider = InferProvider<typeof settingsStoreCapability>;
+/**
+ * tRPC client namespace type for the settings-store capability.
+ * Used as the dependency type for services that need settings persistence.
+ * Methods are accessed as `client.get.query(input)`, `client.set.mutate(input)`, etc.
+ */
+export type SettingsStoreClient = import('../generated/addon-api.js').AddonApi['settingsStore'];
+export { QueryFilterSchema, SettingsRecordSchema, CollectionColumnSchema, CollectionIndexSchema };
+export type CollectionColumn = z.infer<typeof CollectionColumnSchema>;
+export type CollectionIndex = z.infer<typeof CollectionIndexSchema>;
+//# sourceMappingURL=settings-store.cap.d.ts.map

package/dist/capabilities/settings-store.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings-store.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/settings-store.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;GAEG;AACH,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;iBAUrB,CAAA;AAEF,8CAA8C;AAC9C,QAAA,MAAM,oBAAoB;;;iBAGxB,CAAA;AAEF;;;;GAIG;AACH,QAAA,MAAM,sBAAsB;;;;;;;;;;;iBAM1B,CAAA;AAEF,QAAA,MAAM,qBAAqB;;;;iBAIzB,CAAA;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,uBAAuB;;;;;QAKhC,mDAAmD;;;;;;QAMnD,mDAAmD;;;;;;;QAOnD,mDAAmD;;;;;;;;;;;;;;;;;;;;;;QAMnD,2BAA2B;;;;;;;;;QAO3B,uCAAuC;;;;;;;QAOvC,iCAAiC;;;;;;QAOjC,0DAA0D;;;;;;;;;;;;;;;;;;;QAM1D,sCAAsC;;;;;QAMtC;;;;;;;;;;;;;;WAcG;;;;;;;;;;;;;;;;;;;;;;;CAYkC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAElF;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,2BAA2B,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAA;AAE/F,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,CAAA;AAEjG,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA"}