@camstack/types 0.1.14 → 0.1.15

package/dist/capabilities/ptz-autotrack.cap.d.ts

@@ -0,0 +1,188 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+export declare const PtzAutotrackSettingsSchema: z.ZodObject<{
+    targetType: z.ZodString;
+    stopDelaySeconds: z.ZodNumber;
+    disappearDelaySeconds: z.ZodNumber;
+}, z.core.$strip>;
+export type PtzAutotrackSettings = z.infer<typeof PtzAutotrackSettingsSchema>;
+/**
+ * One option the camera advertises as a valid `targetType`. Drivers
+ * harvest this from their probe data; the UI renders these as the
+ * `targetType` select options. Empty array = the camera doesn't
+ * expose a target-type selector (auto-only).
+ *
+ * The `value` is the canonical wire string the cap accepts in
+ * `setSettings({targetType})` — drivers use it verbatim when pushing
+ * to firmware. The `label` is operator-facing English (translated
+ * client-side if the UI supports i18n).
+ */
+export declare const PtzAutotrackTargetOptionSchema: z.ZodObject<{
+    value: z.ZodString;
+    label: z.ZodString;
+}, z.core.$strip>;
+export type PtzAutotrackTargetOption = z.infer<typeof PtzAutotrackTargetOptionSchema>;
+export declare const PtzAutotrackStatusSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    lastChangedAt: z.ZodNumber;
+    currentSettings: z.ZodNullable<z.ZodObject<{
+        targetType: z.ZodString;
+        stopDelaySeconds: z.ZodNumber;
+        disappearDelaySeconds: z.ZodNumber;
+    }, z.core.$strip>>;
+    supportedTargetTypes: z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PtzAutotrackStatus = z.infer<typeof PtzAutotrackStatusSchema>;
+/**
+ * Runtime-state slice owned by this cap. Persists the last-known
+ * camera-derived snapshot across restarts, so cold-start callers
+ * have a meaningful baseline even before the first refresh round-trip.
+ *
+ * Adds `lastFetchedAt` on top of the status shape so the framework
+ * (or the provider) can stale-check before deciding whether to
+ * round-trip the camera again.
+ */
+export declare const PtzAutotrackRuntimeStateSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    lastChangedAt: z.ZodNumber;
+    currentSettings: z.ZodNullable<z.ZodObject<{
+        targetType: z.ZodString;
+        stopDelaySeconds: z.ZodNumber;
+        disappearDelaySeconds: z.ZodNumber;
+    }, z.core.$strip>>;
+    supportedTargetTypes: z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strip>>;
+    lastFetchedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type PtzAutotrackRuntimeState = z.infer<typeof PtzAutotrackRuntimeStateSchema>;
+export declare const ptzAutotrackCapability: {
+    readonly name: "ptz-autotrack";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly methods: {
+        /**
+         * Read the current on/off state + last-applied settings.
+         * Drivers may serve from a cache + refresh on a schedule —
+         * callers should NOT poll faster than ~5s.
+         */
+        readonly getStatus: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            enabled: z.ZodBoolean;
+            lastChangedAt: z.ZodNumber;
+            currentSettings: z.ZodNullable<z.ZodObject<{
+                targetType: z.ZodString;
+                stopDelaySeconds: z.ZodNumber;
+                disappearDelaySeconds: z.ZodNumber;
+            }, z.core.$strip>>;
+            supportedTargetTypes: z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Arm or disarm autotrack. Resolves once the camera has
+         * acknowledged the transition; the `onStatusChanged` event
+         * fires shortly after with the live state.
+         */
+        readonly setEnabled: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            enabled: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /**
+         * Read settings (target type + delays). Mirrors the
+         * `getStatus().currentSettings` payload but exposes it as a
+         * standalone read for callers that want settings without the
+         * status surface around them. `null` until the driver has
+         * harvested the firmware state at least once.
+         */
+        readonly getSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            targetType: z.ZodString;
+            stopDelaySeconds: z.ZodNumber;
+            disappearDelaySeconds: z.ZodNumber;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Update one or more settings. Partial — keys that aren't
+         * supplied keep their last persisted value. The driver is
+         * responsible for clamping vendor-specific ranges if narrower
+         * than the cross-vendor max declared on the schema.
+         */
+        readonly setSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            settings: z.ZodObject<{
+                targetType: z.ZodOptional<z.ZodString>;
+                stopDelaySeconds: z.ZodOptional<z.ZodNumber>;
+                disappearDelaySeconds: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly events: {
+        readonly onStatusChanged: {
+            readonly data: z.ZodObject<{
+                deviceId: z.ZodNumber;
+                status: z.ZodObject<{
+                    enabled: z.ZodBoolean;
+                    lastChangedAt: z.ZodNumber;
+                    currentSettings: z.ZodNullable<z.ZodObject<{
+                        targetType: z.ZodString;
+                        stopDelaySeconds: z.ZodNumber;
+                        disappearDelaySeconds: z.ZodNumber;
+                    }, z.core.$strip>>;
+                    supportedTargetTypes: z.ZodArray<z.ZodObject<{
+                        value: z.ZodString;
+                        label: z.ZodString;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        };
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            lastChangedAt: z.ZodNumber;
+            currentSettings: z.ZodNullable<z.ZodObject<{
+                targetType: z.ZodString;
+                stopDelaySeconds: z.ZodNumber;
+                disappearDelaySeconds: z.ZodNumber;
+            }, z.core.$strip>>;
+            supportedTargetTypes: z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        readonly kind: "command-driven";
+    };
+    /**
+     * Persistent slice mirrored across restarts. The provider writes
+     * here on every successful firmware fetch / settings push;
+     * `getStatus` and `getSettings` then read this snapshot synchronously
+     * with a stale-driven async refresh in the background. Keeps the
+     * fetch / cache / fallback logic out of the four cap methods —
+     * they become trampolines over `runtimeState`.
+     */
+    readonly runtimeState: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        lastChangedAt: z.ZodNumber;
+        currentSettings: z.ZodNullable<z.ZodObject<{
+            targetType: z.ZodString;
+            stopDelaySeconds: z.ZodNumber;
+            disappearDelaySeconds: z.ZodNumber;
+        }, z.core.$strip>>;
+        supportedTargetTypes: z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>>;
+        lastFetchedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IPtzAutotrackProvider = InferProvider<typeof ptzAutotrackCapability>;
+//# sourceMappingURL=ptz-autotrack.cap.d.ts.map

package/dist/capabilities/ptz-autotrack.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ptz-autotrack.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/ptz-autotrack.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAwCrD,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAA;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE7E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,8BAA8B;;;iBAGzC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAErF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;iBAkBnC,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;iBAGzC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAErF,eAAO,MAAM,sBAAsB;;;;;;QAM/B;;;;WAIG;;;;;;;;;;;;;;;;QAKH;;;;WAIG;;;;;QAMH;;;;;;WAMG;;;;;;;;QAKH;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoBL;;;;;;;OAOG;;;;;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

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

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+declare const PtzPresetSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+declare const PtzPositionSchema: z.ZodObject<{
+    pan: z.ZodNumber;
+    tilt: z.ZodNumber;
+    zoom: z.ZodNumber;
+}, z.core.$strip>;
+declare const PtzMoveCommandSchema: z.ZodObject<{
+    pan: z.ZodOptional<z.ZodNumber>;
+    tilt: z.ZodOptional<z.ZodNumber>;
+    zoom: z.ZodOptional<z.ZodNumber>;
+    speed: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const ptzCapability: {
+    readonly name: "ptz";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly methods: {
+        readonly move: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            pan: z.ZodOptional<z.ZodNumber>;
+            tilt: z.ZodOptional<z.ZodNumber>;
+            zoom: z.ZodOptional<z.ZodNumber>;
+            speed: z.ZodOptional<z.ZodNumber>;
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly continuousMove: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            pan: z.ZodOptional<z.ZodNumber>;
+            tilt: z.ZodOptional<z.ZodNumber>;
+            zoom: z.ZodOptional<z.ZodNumber>;
+            speed: z.ZodOptional<z.ZodNumber>;
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly stop: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly getPresets: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly goToPreset: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            presetId: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly goHome: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /**
+         * Pull the current PTZ position. Redundant with the auto-injected
+         * `getStatus` method (see `status` below); kept for callers that
+         * haven't migrated. Will be folded into `getStatus` in a future
+         * cleanup pass once all consumers use the typed status surface.
+         */
+        readonly getPosition: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            pan: z.ZodNumber;
+            tilt: z.ZodNumber;
+            zoom: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            pan: z.ZodNumber;
+            tilt: z.ZodNumber;
+            zoom: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "command-driven";
+    };
+};
+export type IPtzProvider = InferProvider<typeof ptzCapability>;
+export { PtzPresetSchema, PtzPositionSchema, PtzMoveCommandSchema };
+//# sourceMappingURL=ptz.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ptz.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/ptz.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD,QAAA,MAAM,eAAe;;;iBAAiD,CAAA;AACtE,QAAA,MAAM,iBAAiB;;;;iBAAoE,CAAA;AAC3F,QAAA,MAAM,oBAAoB;;;;;iBAKxB,CAAA;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAmCtB;;;;;WAKG;;;;;;;;;;;;;;;;;CAUkC,CAAA;AAEzC,MAAM,MAAM,YAAY,GAAG,aAAa,CAAC,OAAO,aAAa,CAAC,CAAA;AAC9D,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,CAAA"}

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

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * reboot — device-scoped capability for "soft" device reboots (firmware
+ * reboot via vendor protocol; cameras, NVRs, doorbells). Surfaces a
+ * single mutation so the UI can offer a confirm-and-reboot button for
+ * any device whose driver advertises `DeviceFeature.Rebootable`.
+ *
+ * Implementation contract: the driver SHOULD return only after the
+ * remote acknowledges the request (camera will go offline shortly
+ * after). Wrappers in the addon should NOT block on the device coming
+ * back online — operators read the device-online indicator for that.
+ *
+ * Errors propagate verbatim: a 401 from the camera surfaces as a tRPC
+ * error to the UI, which renders it next to the button.
+ */
+export declare const rebootCapability: {
+    readonly name: "reboot";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera, DeviceType.Sensor, DeviceType.Switch];
+    readonly methods: {
+        readonly reboot: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+    };
+};
+export type IRebootProvider = InferProvider<typeof rebootCapability>;
+//# sourceMappingURL=reboot.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reboot.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/reboot.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;CAYY,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA"}