@camstack/types 1.2.16 → 1.2.17

package/dist/interfaces/addon.d.ts

@@ -326,6 +326,15 @@ export interface IKernelServices {
         readonly capName: string;
         readonly deviceId: number;
     }>;
+    /**
+     * Node-routed capability proxy (hub-side builtins only): every method call
+     * on the returned object forwards to `capName`'s provider ON `nodeId` via
+     * the cluster transport — the same routing the generated cap routers use
+     * for `{nodeId}` inputs. Null when the capability is not reachable on that
+     * node. Lets a hub builtin (e.g. storage-orchestrator) execute work WHERE
+     * the data lives instead of assuming its own filesystem.
+     */
+    readonly resolveNodeCapability?: (capName: string, nodeId: string) => Record<string, (params: unknown) => Promise<unknown>> | null;
 }
 /**
  * Canonical hwaccel backend names. Accepted by both the `ffmpeg` CLI

package/dist/interfaces/ops-log.d.ts

@@ -22,6 +22,7 @@ export declare const OpsLogOpSchema: z.ZodEnum<{
     "manual-delete": "manual-delete";
     rescan: "rescan";
     "retention-run": "retention-run";
+    relocate: "relocate";
 }>;
 export type OpsLogOp = z.infer<typeof OpsLogOpSchema>;
 /** Why the operation ran. */
@@ -45,6 +46,7 @@ export declare const OpsLogEntrySchema: z.ZodObject<{
         "manual-delete": "manual-delete";
         rescan: "rescan";
         "retention-run": "retention-run";
+        relocate: "relocate";
     }>;
     reason: z.ZodEnum<{
         manual: "manual";

package/dist/interfaces/recording-config.d.ts

@@ -26,31 +26,15 @@ export type EventPadMs = typeof EVENT_PAD_MS;
  */
 export declare const RecordingWeekdaySchema: z.ZodNumber;
 export type RecordingWeekday = z.infer<typeof RecordingWeekdaySchema>;
-export declare const RecordingScheduleSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"always">;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"timeOfDay">;
-    start: z.ZodString;
-    end: z.ZodString;
-    days: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-}, z.core.$strip>], "kind">;
-export type RecordingSchedule = z.infer<typeof RecordingScheduleSchema>;
-export declare const RecordingModeSchema: z.ZodEnum<{
-    onMotion: "onMotion";
-    continuous: "continuous";
-    onAudioThreshold: "onAudioThreshold";
-}>;
-export type RecordingMode = z.infer<typeof RecordingModeSchema>;
 /**
- * First-class, authoritative per-camera storage mode — the explicit choice the
- * UI reads directly (never inferred from `rules`):
- *  - `off`        — not recording.
- *  - `events`     — record only around triggers (motion / audio threshold),
- *                   with pre/post-buffer.
- *  - `continuous` — record 24/7 within the schedule.
+ * DERIVED per-camera storage summary — the single field cheap consumers read
+ * (the viewer's status dot, the camera list) instead of walking `bands`:
+ *  - `off`        — no band covers the camera (or it is disabled).
+ *  - `events`     — every band records around triggers only.
+ *  - `continuous` — at least one band records continuously.
  *
- * `mode` compiles one-way to the internal `rules[]` consumed by the policy
- * engine (see `compileRules`); `rules[]` is never authored directly anymore.
+ * NEVER authored: the recorder stamps it from the authoritative `bands` on
+ * every save (`activeModeForConfig`). Writing it has no effect.
  */
 export declare const RecordingStorageModeSchema: z.ZodEnum<{
     events: "events";
@@ -58,7 +42,7 @@ export declare const RecordingStorageModeSchema: z.ZodEnum<{
     continuous: "continuous";
 }>;
 export type RecordingStorageMode = z.infer<typeof RecordingStorageModeSchema>;
-/** Which detectors trigger an `events`-mode recording. */
+/** Which detectors trigger an `events`-mode band. */
 export declare const RecordingTriggersSchema: z.ZodObject<{
     motion: z.ZodOptional<z.ZodBoolean>;
     audioThresholdDbfs: z.ZodOptional<z.ZodNumber>;
@@ -110,26 +94,6 @@ export declare const RecordingBandSchema: z.ZodObject<{
     postBufferSec: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type RecordingBand = z.infer<typeof RecordingBandSchema>;
-export declare const RecordingRuleSchema: z.ZodObject<{
-    schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"always">;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"timeOfDay">;
-        start: z.ZodString;
-        end: z.ZodString;
-        days: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-    }, z.core.$strip>], "kind">;
-    mode: z.ZodEnum<{
-        onMotion: "onMotion";
-        continuous: "continuous";
-        onAudioThreshold: "onAudioThreshold";
-    }>;
-    preBufferSec: z.ZodDefault<z.ZodNumber>;
-    postBufferSec: z.ZodDefault<z.ZodNumber>;
-    resetTimeoutOnNewEvent: z.ZodDefault<z.ZodBoolean>;
-    thresholdDbfs: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export type RecordingRule = z.infer<typeof RecordingRuleSchema>;
 /**
  * Per-device retention overrides. Every field is optional; an unset or `0`
  * value inherits the node-wide recorder default. Only footage-lifetime limits
@@ -193,10 +157,14 @@ export declare function resolveScrubThumbnailGeometry(preset: ScrubThumbnailPres
 /**
  * The full per-camera recording intent — the wire shape of a RecordingTarget.
  *
- * `mode` is the authoritative storage choice; `schedule`/`triggers`/`pre`/`post`
- * are its mode-specific parameters. `rules` is a DEPRECATED authoring input kept
- * only for transition + migration (`migrateRulesToMode`); the policy engine
- * consumes the compiled output of `compileRules(config)`, never `rules` directly.
+ * `bands` is the ONLY authored recording intent: what to record, when, and on
+ * which trigger. `mode` is a derived summary the recorder stamps on save; every
+ * other field is a storage knob (profiles, segment length, retention, scrub).
+ *
+ * STRICT on purpose: the legacy authoring surface (`schedule`/`schedules`/
+ * `triggers`/`preBufferSec`/`postBufferSec`/`rules`) was retired 2026-07-30.
+ * A stale caller must fail loudly — silently stripping its legacy intent would
+ * persist a band-less config, i.e. silently stop recording the camera.
  */
 export declare const RecordingConfigSchema: z.ZodObject<{
     enabled: z.ZodBoolean;
@@ -211,48 +179,7 @@ export declare const RecordingConfigSchema: z.ZodObject<{
         low: "low";
     }>>>;
     segmentSeconds: z.ZodOptional<z.ZodNumber>;
-    schedules: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"always">;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"timeOfDay">;
-        start: z.ZodString;
-        end: z.ZodString;
-        days: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-    }, z.core.$strip>], "kind">>>;
-    schedule: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"always">;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"timeOfDay">;
-        start: z.ZodString;
-        end: z.ZodString;
-        days: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-    }, z.core.$strip>], "kind">>;
-    triggers: z.ZodOptional<z.ZodObject<{
-        motion: z.ZodOptional<z.ZodBoolean>;
-        audioThresholdDbfs: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    preBufferSec: z.ZodOptional<z.ZodNumber>;
-    postBufferSec: z.ZodOptional<z.ZodNumber>;
-    rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"always">;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<"timeOfDay">;
-            start: z.ZodString;
-            end: z.ZodString;
-            days: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-        }, z.core.$strip>], "kind">;
-        mode: z.ZodEnum<{
-            onMotion: "onMotion";
-            continuous: "continuous";
-            onAudioThreshold: "onAudioThreshold";
-        }>;
-        preBufferSec: z.ZodDefault<z.ZodNumber>;
-        postBufferSec: z.ZodDefault<z.ZodNumber>;
-        resetTimeoutOnNewEvent: z.ZodDefault<z.ZodBoolean>;
-        thresholdDbfs: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>>;
-    bands: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    bands: z.ZodDefault<z.ZodArray<z.ZodObject<{
         days: z.ZodArray<z.ZodNumber>;
         start: z.ZodString;
         end: z.ZodString;
@@ -278,5 +205,20 @@ export declare const RecordingConfigSchema: z.ZodObject<{
         max: "max";
         minimal: "minimal";
     }>>;
-}, z.core.$strip>;
+    stripsEnabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
 export type RecordingConfig = z.infer<typeof RecordingConfigSchema>;
+/** The bands + enabled flag a mode is derived from — all {@link deriveRecordingMode} reads. */
+export type RecordingModeSource = Pick<RecordingConfig, 'enabled' | 'bands'>;
+/**
+ * Derive the {@link RecordingStorageModeSchema} summary from the authoritative
+ * bands: `continuous` when any band records continuously, `events` when a band
+ * exists at all, else `off`. Pure.
+ *
+ * THE one definition: the recorder stamps `config.mode` with it on save and
+ * reports it as the cap's `activeMode`, and the settings UI reads it back to
+ * decide which authoring tab a config opens in. Two copies would drift, and the
+ * symptom (a status dot disagreeing with what is being recorded) is exactly the
+ * bug this field was added to fix.
+ */
+export declare function deriveRecordingMode(config: RecordingModeSource): RecordingStorageMode;

package/dist/interfaces/relocate.d.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+/**
+ * Entity-relocation job state (storage entity-routing spec, Phase 4).
+ *
+ * One shape shared by the recorder's `relocateFootage` (segments + strips) and
+ * pipeline-analytics' `relocateMedia` (event media blobs) so the admin Data
+ * page renders both movers with one component. Jobs are in-RAM (a restart
+ * forgets them — re-running is safe by construction: copy-if-absent, delete
+ * after verify) and each completed/failed run also lands one durable ops-log
+ * row on the owning addon's surface.
+ */
+export declare const RelocateJobStateSchema: z.ZodEnum<{
+    running: "running";
+    done: "done";
+    failed: "failed";
+    cancelled: "cancelled";
+}>;
+export type RelocateJobState = z.infer<typeof RelocateJobStateSchema>;
+export declare const RelocateJobSchema: z.ZodObject<{
+    jobId: z.ZodString;
+    state: z.ZodEnum<{
+        running: "running";
+        done: "done";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>;
+    fromLocationId: z.ZodString;
+    toLocationId: z.ZodString;
+    deviceId: z.ZodNullable<z.ZodNumber>;
+    entities: z.ZodArray<z.ZodString>;
+    filesMoved: z.ZodNumber;
+    bytesMoved: z.ZodNumber;
+    filesTotal: z.ZodNullable<z.ZodNumber>;
+    startedAt: z.ZodNumber;
+    finishedAt: z.ZodNullable<z.ZodNumber>;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type RelocateJob = z.infer<typeof RelocateJobSchema>;
+export declare const RelocateFootageInputSchema: z.ZodObject<{
+    deviceId: z.ZodOptional<z.ZodNumber>;
+    fromLocationId: z.ZodString;
+    toLocationId: z.ZodString;
+    entities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        segments: "segments";
+        strips: "strips";
+    }>>>;
+    throttleMbps: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type RelocateFootageInput = z.infer<typeof RelocateFootageInputSchema>;
+export declare const RelocateMediaInputSchema: z.ZodObject<{
+    deviceId: z.ZodOptional<z.ZodNumber>;
+    toLocationId: z.ZodString;
+    throttleMbps: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type RelocateMediaInput = z.infer<typeof RelocateMediaInputSchema>;

package/dist/interfaces/storage-location-declaration.d.ts

@@ -30,8 +30,8 @@ export declare const StorageLocationDeclarationSchema: z.ZodObject<{
     defaultsTo: z.ZodOptional<z.ZodString>;
     defaultRoot: z.ZodOptional<z.ZodEnum<{
         data: "data";
-        media: "media";
         backup: "backup";
+        media: "media";
     }>>;
 }, z.core.$strip>;
 /** Inferred TypeScript type for `StorageLocationDeclarationSchema`. */

package/dist/interfaces/storage-location.d.ts

@@ -48,6 +48,10 @@ export declare const StorageLocationSchema: z.ZodObject<{
     nodeId: z.ZodOptional<z.ZodString>;
     isDefault: z.ZodDefault<z.ZodBoolean>;
     isSystem: z.ZodDefault<z.ZodBoolean>;
+    capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        totalBytes: z.ZodNumber;
+        availableBytes: z.ZodNumber;
+    }, z.core.$strip>>>;
     createdAt: z.ZodNumber;
     updatedAt: z.ZodNumber;
 }, z.core.$strip>;

package/dist/interfaces/stream-broker.d.ts

@@ -28,8 +28,8 @@ export declare const DecoderSessionConfigSchema: z.ZodObject<{
     deviceId: z.ZodOptional<z.ZodNumber>;
     tag: z.ZodOptional<z.ZodString>;
     frameSink: z.ZodDefault<z.ZodEnum<{
-        callback: "callback";
         shm: "shm";
+        callback: "callback";
     }>>;
     debug: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;

package/dist/lifecycle/job.d.ts

@@ -7,7 +7,6 @@ export declare const jobKindSchema: z.ZodEnum<{
 }>;
 export type JobKind = z.infer<typeof jobKindSchema>;
 export declare const taskPhaseSchema: z.ZodEnum<{
-    failed: "failed";
     queued: "queued";
     fetching: "fetching";
     staged: "staged";
@@ -16,6 +15,7 @@ export declare const taskPhaseSchema: z.ZodEnum<{
     restarting: "restarting";
     applied: "applied";
     done: "done";
+    failed: "failed";
     skipped: "skipped";
 }>;
 export type TaskPhase = z.infer<typeof taskPhaseSchema>;
@@ -29,7 +29,6 @@ export declare const taskLogEntrySchema: z.ZodObject<{
     nodeId: z.ZodString;
     packageName: z.ZodString;
     phase: z.ZodEnum<{
-        failed: "failed";
         queued: "queued";
         fetching: "fetching";
         staged: "staged";
@@ -38,6 +37,7 @@ export declare const taskLogEntrySchema: z.ZodObject<{
         restarting: "restarting";
         applied: "applied";
         done: "done";
+        failed: "failed";
         skipped: "skipped";
     }>;
     message: z.ZodString;
@@ -54,7 +54,6 @@ export declare const lifecycleTaskSchema: z.ZodObject<{
         addon: "addon";
     }>;
     phase: z.ZodEnum<{
-        failed: "failed";
         queued: "queued";
         fetching: "fetching";
         staged: "staged";
@@ -63,6 +62,7 @@ export declare const lifecycleTaskSchema: z.ZodObject<{
         restarting: "restarting";
         applied: "applied";
         done: "done";
+        failed: "failed";
         skipped: "skipped";
     }>;
     stagedPath: z.ZodNullable<z.ZodString>;
@@ -72,7 +72,6 @@ export declare const lifecycleTaskSchema: z.ZodObject<{
         nodeId: z.ZodString;
         packageName: z.ZodString;
         phase: z.ZodEnum<{
-            failed: "failed";
             queued: "queued";
             fetching: "fetching";
             staged: "staged";
@@ -81,6 +80,7 @@ export declare const lifecycleTaskSchema: z.ZodObject<{
             restarting: "restarting";
             applied: "applied";
             done: "done";
+            failed: "failed";
             skipped: "skipped";
         }>;
         message: z.ZodString;
@@ -130,7 +130,6 @@ export declare const lifecycleJobSchema: z.ZodObject<{
             addon: "addon";
         }>;
         phase: z.ZodEnum<{
-            failed: "failed";
             queued: "queued";
             fetching: "fetching";
             staged: "staged";
@@ -139,6 +138,7 @@ export declare const lifecycleJobSchema: z.ZodObject<{
             restarting: "restarting";
             applied: "applied";
             done: "done";
+            failed: "failed";
             skipped: "skipped";
         }>;
         stagedPath: z.ZodNullable<z.ZodString>;
@@ -148,7 +148,6 @@ export declare const lifecycleJobSchema: z.ZodObject<{
             nodeId: z.ZodString;
             packageName: z.ZodString;
             phase: z.ZodEnum<{
-                failed: "failed";
                 queued: "queued";
                 fetching: "fetching";
                 staged: "staged";
@@ -157,6 +156,7 @@ export declare const lifecycleJobSchema: z.ZodObject<{
                 restarting: "restarting";
                 applied: "applied";
                 done: "done";
+                failed: "failed";
                 skipped: "skipped";
             }>;
             message: z.ZodString;

package/dist/node.js

@@ -517,6 +517,7 @@ var FilesystemStorageProvider = class {
 				this.locationPaths.set(loc, node_path.isAbsolute(subdir) ? subdir : node_path.join(this.rootPath, subdir));
 			}
 		}
+		for (const [loc, override] of Object.entries(overrides ?? {})) if (typeof override === "string" && !this.locationPaths.has(loc)) this.locationPaths.set(loc, node_path.resolve(override));
 	}
 	async resolve({ location, relativePath }) {
 		const base = this.locationPaths.get(location) ?? node_path.join(this.rootPath, location);

package/dist/node.mjs

@@ -494,6 +494,7 @@ var FilesystemStorageProvider = class {
 				this.locationPaths.set(loc, path.isAbsolute(subdir) ? subdir : path.join(this.rootPath, subdir));
 			}
 		}
+		for (const [loc, override] of Object.entries(overrides ?? {})) if (typeof override === "string" && !this.locationPaths.has(loc)) this.locationPaths.set(loc, path.resolve(override));
 	}
 	async resolve({ location, relativePath }) {
 		const base = this.locationPaths.get(location) ?? path.join(this.rootPath, location);

package/dist/notification/condition-taxonomy.d.ts

@@ -0,0 +1,61 @@
+/**
+ * condition-taxonomy — pure mapping from a notification-rule condition id to a
+ * grouped picker model, driven by the server's `NcTaxonomy` (video classes +
+ * audio kinds + sensor/control labels).
+ *
+ * WHY IT LIVES HERE
+ * ─────────────────
+ * It was written in the viewer and is the correct model — macro→sub grouping,
+ * translated headers with an English fallback, free text kept as a deliberate
+ * escape hatch. The admin UI had none of it and rendered every list condition
+ * as a free-text tag input, so an operator had to TYPE `person` / `vehicle`
+ * from memory and type a zone's *id* rather than pick its name, and a typo
+ * produced a rule that silently never matched.
+ *
+ * Copying it into the admin UI would leave two implementations of "which
+ * vocabulary backs which condition" free to drift. It is UI-framework-free by
+ * construction, so it is hoisted here — beside `degrade-engine.ts`, the
+ * existing precedent for pure notification logic in this package — and both
+ * surfaces consume it.
+ *
+ * A condition with no fixed vocabulary (identities, plates, raw event tokens,
+ * admin zone ids) returns `null` and keeps its free-text input. Conditions WITH
+ * a vocabulary keep free text too, as an escape hatch for values the taxonomy
+ * does not know.
+ */
+import type { NcTaxonomy } from '../catalogs/nc-taxonomy.js';
+/** One selectable option inside a picker group. */
+export interface TaxonomyOption {
+    readonly value: string;
+    readonly label: string;
+}
+/** A labelled group of options (rendered under a translated header). */
+export interface TaxonomyGroup {
+    /** i18n sub-key under `v2.nc.rules.editor.taxonomy.` */
+    readonly key: string;
+    /** English fallback header when the i18n key is missing. */
+    readonly fallbackLabel: string;
+    readonly options: readonly TaxonomyOption[];
+}
+/** The picker model for one condition, or `null` when it stays free-text. */
+export interface TaxonomyPicker {
+    readonly groups: readonly TaxonomyGroup[];
+}
+/**
+ * Build the grouped picker model for a condition id, or `null` when the
+ * condition has no fixed vocabulary (→ free-text tag input).
+ */
+export declare function pickerForCondition(conditionId: string, taxonomy: NcTaxonomy | undefined): TaxonomyPicker | null;
+/** All option values across a picker's groups (for custom-value detection). */
+export declare function knownValues(picker: TaxonomyPicker): ReadonlySet<string>;
+/**
+ * The condition ids shown in the ALWAYS-VISIBLE area of a rule editor. Every
+ * other catalog descriptor is advanced and lives behind an expander.
+ *
+ * Shared for the same reason as the picker model: two surfaces disagreeing
+ * about what counts as "basic" is a worse outcome than either choice.
+ */
+export declare const NC_BASE_CONDITION_KEYS: readonly ["devices", "classes"];
+export type NcBaseConditionKey = (typeof NC_BASE_CONDITION_KEYS)[number];
+/** True when a condition key belongs to the BASE surface. */
+export declare function isBaseConditionKey(key: string): boolean;

package/dist/notification/format-transcode.d.ts

@@ -13,7 +13,18 @@ export declare function htmlToText(html: string): string;
 export declare function textToHtml(text: string): string;
 /** Markdown → HTML-lite (bold/italic/code/links; used e.g. for Pushover). */
 export declare function markdownToHtmlLite(md: string): string;
-/** Pick the best target format the kind supports for a given source format. */
+/**
+ * Pick the best target format the kind supports for a given source format.
+ *
+ * TOLERANT of a source outside the union. `NotificationSchema.format` carries
+ * `.default('text')`, but that default only runs where the schema is PARSED —
+ * the tRPC router. A cap call arriving from another addon (`ctx.api`) skips
+ * that parse, so `format` reaches here `undefined`, and the bare
+ * `DEGRADE_ORDER[source]` threw `is not iterable`. That broke the one promise
+ * the degrade path makes ("never throws — degradation is reported, never
+ * surfaced as an error") and dead-lettered every Notification-Center delivery
+ * for a day (2026-07-30). An unknown source degrades like `text`.
+ */
 export declare function resolveFormat(source: NotificationFormat, supported: readonly NotificationFormat[]): NotificationFormat;
 /** Transcode a body between formats. */
 export declare function transcodeBody(body: string, from: NotificationFormat, to: NotificationFormat): string;

package/dist/{sleep-C3ceNSsf.mjs → sleep-Ct4Is70g.mjs}

@@ -3019,6 +3019,9 @@ function createDeviceProxy(api, binding, opts) {
 			getEventStoreFootprint: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getEventStoreFootprint", "query", input),
 			pruneEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "pruneEvents", "mutation", input),
 			deleteDeviceEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "deleteDeviceEvents", "mutation", input),
+			relocateMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "relocateMedia", "mutation", input),
+			getMediaRelocateStatus: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getMediaRelocateStatus", "query", input),
+			cancelMediaRelocate: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "cancelMediaRelocate", "mutation", input),
 			listOpsLog: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listOpsLog", "query", input),
 			getEventMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getEventMedia", "query", input),
 			getTrackMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getTrackMedia", "query", input),
@@ -3269,6 +3272,8 @@ function createDeviceProxy(api, binding, opts) {
 			rescanStorage: (input) => dispatchSystem("recording", "rescanStorage", "mutation", input),
 			pruneFootage: (input) => dispatchSystem("recording", "pruneFootage", "mutation", input),
 			deleteFootprint: (input) => dispatchSystem("recording", "deleteFootprint", "mutation", input),
+			renderGif: (input) => dispatchSystem("recording", "renderGif", "mutation", input),
+			renderClip: (input) => dispatchSystem("recording", "renderClip", "mutation", input),
 			getStatus: (input) => dispatchSystem("recording", "getStatus", "query", input),
 			getDeviceSettingsContribution: (input) => dispatchSystem("recording", "getDeviceSettingsContribution", "query", input),
 			getDeviceLiveContribution: (input) => dispatchSystem("recording", "getDeviceLiveContribution", "query", input),
@@ -3283,6 +3288,7 @@ function createDeviceProxy(api, binding, opts) {
 			retractCameraStream: (input) => dispatchSystem("streamBroker", "retractCameraStream", "mutation", input),
 			assignProfile: (input) => dispatchSystem("streamBroker", "assignProfile", "mutation", input),
 			unassignProfile: (input) => dispatchSystem("streamBroker", "unassignProfile", "mutation", input),
+			renderPreBufferClip: (input) => dispatchSystem("streamBroker", "renderPreBufferClip", "mutation", input),
 			restartProfile: (input) => dispatchSystem("streamBroker", "restartProfile", "mutation", input),
 			getDeviceSettingsContribution: (input) => dispatchSystem("streamBroker", "getDeviceSettingsContribution", "query", input),
 			getDeviceLiveContribution: (input) => dispatchSystem("streamBroker", "getDeviceLiveContribution", "query", input),

package/dist/{sleep-DRg9F6JJ.js → sleep-yfPaamGa.js}

@@ -3019,6 +3019,9 @@ function createDeviceProxy(api, binding, opts) {
 			getEventStoreFootprint: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getEventStoreFootprint", "query", input),
 			pruneEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "pruneEvents", "mutation", input),
 			deleteDeviceEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "deleteDeviceEvents", "mutation", input),
+			relocateMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "relocateMedia", "mutation", input),
+			getMediaRelocateStatus: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getMediaRelocateStatus", "query", input),
+			cancelMediaRelocate: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "cancelMediaRelocate", "mutation", input),
 			listOpsLog: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listOpsLog", "query", input),
 			getEventMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getEventMedia", "query", input),
 			getTrackMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getTrackMedia", "query", input),
@@ -3269,6 +3272,8 @@ function createDeviceProxy(api, binding, opts) {
 			rescanStorage: (input) => dispatchSystem("recording", "rescanStorage", "mutation", input),
 			pruneFootage: (input) => dispatchSystem("recording", "pruneFootage", "mutation", input),
 			deleteFootprint: (input) => dispatchSystem("recording", "deleteFootprint", "mutation", input),
+			renderGif: (input) => dispatchSystem("recording", "renderGif", "mutation", input),
+			renderClip: (input) => dispatchSystem("recording", "renderClip", "mutation", input),
 			getStatus: (input) => dispatchSystem("recording", "getStatus", "query", input),
 			getDeviceSettingsContribution: (input) => dispatchSystem("recording", "getDeviceSettingsContribution", "query", input),
 			getDeviceLiveContribution: (input) => dispatchSystem("recording", "getDeviceLiveContribution", "query", input),
@@ -3283,6 +3288,7 @@ function createDeviceProxy(api, binding, opts) {
 			retractCameraStream: (input) => dispatchSystem("streamBroker", "retractCameraStream", "mutation", input),
 			assignProfile: (input) => dispatchSystem("streamBroker", "assignProfile", "mutation", input),
 			unassignProfile: (input) => dispatchSystem("streamBroker", "unassignProfile", "mutation", input),
+			renderPreBufferClip: (input) => dispatchSystem("streamBroker", "renderPreBufferClip", "mutation", input),
 			restartProfile: (input) => dispatchSystem("streamBroker", "restartProfile", "mutation", input),
 			getDeviceSettingsContribution: (input) => dispatchSystem("streamBroker", "getDeviceSettingsContribution", "query", input),
 			getDeviceLiveContribution: (input) => dispatchSystem("streamBroker", "getDeviceLiveContribution", "query", input),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/types",
-  "version": "1.2.16",
+  "version": "1.2.17",
   "description": "Shared types, interfaces, and model catalogs for the CamStack detection ecosystem",
   "keywords": [
     "camstack",

package/dist/interfaces/recording-config-migrate.d.ts

@@ -1,12 +0,0 @@
-import type { RecordingConfig, RecordingBand } from './recording-config.js';
-/**
- * One-way migration from the legacy recording-config shape to the authoritative
- * mode-per-band model. Pure (no clock access).
- *
- * - If `config.bands` is present, it is authoritative and returned as-is.
- * - Otherwise the result is derived from the legacy fields: a disabled config or
- *   `mode: 'off'` yields no bands; every legacy schedule maps to one band whose
- *   mode is `continuous` when `config.mode === 'continuous'`, else `events`
- *   (carrying `triggers`/`preBufferSec`/`postBufferSec`).
- */
-export declare function migrateConfigToBands(config: RecordingConfig): RecordingBand[];