@camstack/types 1.2.124 → 1.2.127

package/dist/interfaces/addon.d.ts

@@ -1025,6 +1025,36 @@ export interface AddonDeclaration {
      * `ctx.deps.installPythonRequirements(absolutePath)`.
      */
     readonly python?: AddonPythonRequirements;
+    /**
+     * Host binaries this addon needs on PATH. Same declaration site, same
+     * lifecycle position and same idempotence contract as {@link python} —
+     * the runner satisfies them BEFORE `onInitialize()` runs, so a capability
+     * never advertises itself while the binary it wraps is missing.
+     *
+     * The declaration names WHAT is needed (a binary) plus the package name
+     * each host package manager knows it by — a translation table, not a
+     * procedure. HOW to install (`apt-get update && apt-get install -y …`,
+     * `brew install …`) belongs to the framework, so the next addon that needs
+     * a binary does not re-answer the question.
+     *
+     * Example:
+     *   ```jsonc
+     *   "camstack": {
+     *     "addons": [{
+     *       "id": "smb-storage",
+     *       "systemDependencies": [
+     *         { "binary": "smbclient", "packages": { "apt": "smbclient", "brew": "samba" } }
+     *       ]
+     *     }]
+     *   }
+     *   ```
+     *
+     * Failure is NOT fatal: the addon still loads and the capability that needs
+     * the binary must refuse loudly on its own surface. A provider that cannot
+     * run must never make its locations read as *empty* — `empty` is deletable
+     * (D293).
+     */
+    readonly systemDependencies?: readonly AddonSystemDependency[];
     /** Default configuration values */
     readonly defaultConfig?: Readonly<Record<string, unknown>>;
     /**
@@ -1046,6 +1076,43 @@ export interface AddonPythonRequirements {
      */
     readonly requirements: string;
 }
+/**
+ * One host binary an addon needs on PATH. See
+ * `AddonDeclaration.systemDependencies`.
+ *
+ * Deliberately NOT a shell command. A manifest that carried
+ * `"install": "apt-get install -y smbclient"` would be a per-addon script the
+ * framework runs blind — unportable, unverifiable, and a second answer to a
+ * question the Python mechanism already answered once.
+ */
+export interface AddonSystemDependency {
+    /**
+     * The executable that must resolve on PATH after the step completes. This
+     * is both the presence check (cheap, and what makes the common path a
+     * no-op) and the success check.
+     */
+    readonly binary: string;
+    /**
+     * Package name per host package manager. A manager absent from this map
+     * means "this addon has no way to install the binary on that host" — the
+     * runner logs it and continues rather than guessing that the package shares
+     * the binary's name.
+     */
+    readonly packages: AddonSystemDependencyPackages;
+    /** Operator-facing reason, surfaced in the log line when the install fails. */
+    readonly reason?: string;
+}
+/** Package name per supported host package manager. */
+export interface AddonSystemDependencyPackages {
+    /** Debian / Ubuntu (`apt-get`) — the container base. */
+    readonly apt?: string;
+    /** Alpine (`apk`). */
+    readonly apk?: string;
+    /** Fedora / RHEL (`dnf`). */
+    readonly dnf?: string;
+    /** macOS Homebrew (`brew`) — the desktop build. */
+    readonly brew?: string;
+}
 export interface AddonPackageManifest {
     /**
      * Human-readable package name for UI display (e.g., "Pipeline", "Core").

package/dist/interfaces/config-ui-secrets.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Secret-field discovery over a {@link ConfigUISchema}.
+ *
+ * A provider already declares its own form. That declaration is the ONLY place
+ * that knows which of its config keys hold a credential, so redaction reads it
+ * rather than keeping a second, hand-maintained key list somewhere in the
+ * orchestrator — a list that would be right on the day it was written and
+ * wrong on the day a provider gained a field.
+ *
+ * The discriminator is deliberately NOT `type === 'password'` alone. That was
+ * the first design and it is wrong: the SFTP provider's `privateKey` is a
+ * `textarea` holding a full PEM key. Keying off the input widget would have
+ * left it on the wire while reporting that secrets were redacted. See
+ * `ConfigFieldBase.secret`.
+ *
+ * The walk takes `unknown` because that is what the caller has: the
+ * `storage-provider` cap declares `configSchema: z.unknown()`, so a provider's
+ * schema arrives structurally unverified. It narrows defensively at every
+ * step and ignores anything it cannot read — an unreadable node contributes no
+ * keys, which is the direction that under-reports rather than over-reports.
+ * A caller that needs "did I understand this schema at all" asks
+ * {@link schemaDeclaresAnyField}, which answers `false` for a shape this
+ * cannot read, so "no secrets" and "no schema" stay distinguishable.
+ */
+import type { ConfigField } from './config-ui.js';
+/**
+ * The value a redacted secret is replaced with on every read surface.
+ *
+ * It is also the WRITE-BACK token: an `upsertLocation` that sends this value
+ * back for a key means "keep what is stored", which is what lets an operator
+ * rename a location without retyping its password. A literal an operator could
+ * plausibly choose as a real password would turn that convenience into a way
+ * to lock yourself out, hence the sentinel shape.
+ */
+export declare const REDACTED_SECRET = "__camstack_redacted__";
+/** Is this field's stored value a credential? */
+export declare function isSecretConfigField(field: ConfigField): boolean;
+/**
+ * Every config key in `schema` whose value is a secret, including keys nested
+ * inside `group` / `sub-tabs` containers.
+ */
+export declare function collectSecretConfigKeys(schema: unknown): ReadonlySet<string>;
+/**
+ * True when the value is a readable schema declaring at least one field of any
+ * kind. Lets a caller tell "this provider has no secrets" from "this provider's
+ * schema could not be read", which are the same empty set otherwise.
+ */
+export declare function schemaDeclaresAnyField(schema: unknown): boolean;

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

@@ -124,6 +124,23 @@ export interface ConfigFieldBase {
     readonly default?: unknown;
     readonly span?: 1 | 2 | 3 | 4;
     readonly showWhen?: ConfigCondition;
+    /**
+     * The field's stored value is a CREDENTIAL and must never leave the process
+     * on a read surface. Redaction machinery keys off
+     * {@link isSecretConfigField}, which treats `type: 'password'` as implicitly
+     * secret — this flag exists for the fields that carry a secret WITHOUT being
+     * a password input.
+     *
+     * The concrete miss it was added for: the SFTP provider's `privateKey` is a
+     * `textarea` (a PEM block does not fit a one-line password box) holding a
+     * complete SSH private key. A redaction that trusted `type: 'password'`
+     * alone would have shipped with that key still on the wire and an assurance
+     * that credentials were redacted — worse than no redaction at all.
+     *
+     * Mark it on any field whose value would compromise something if read by a
+     * non-admin session. It costs nothing when the field is already a password.
+     */
+    readonly secret?: boolean;
     /** Per-model knob applicability — see {@link ConfigFieldModelApplicability}. */
     readonly modelApplicability?: ConfigFieldModelApplicability;
     /**

package/dist/interfaces/relocate.d.ts

@@ -39,6 +39,7 @@ export declare const RelocateJobSchema: z.ZodObject<{
     filesMoved: z.ZodNumber;
     bytesMoved: z.ZodNumber;
     filesTotal: z.ZodNullable<z.ZodNumber>;
+    rowsReconciled: z.ZodOptional<z.ZodNumber>;
     startedAt: z.ZodNumber;
     finishedAt: z.ZodNullable<z.ZodNumber>;
     error: z.ZodNullable<z.ZodString>;
@@ -128,14 +129,47 @@ export declare const RelocateMediaInputSchema: z.ZodObject<{
     }>>;
 }, z.core.$strip>;
 export type RelocateMediaInput = z.infer<typeof RelocateMediaInputSchema>;
-/** How many rows still carry NO `locationId` — the population a repoint would
- *  silently re-aim at a disk that does not hold their bytes. Zero is the only
- *  value that permits a non-blocking `eventMedia` cutover. */
-export declare const UnstampedEventMediaCountSchema: z.ZodObject<{
-    media: z.ZodNumber;
-    retrainFrames: z.ZodNumber;
-    total: z.ZodNumber;
+/**
+ * The unstamped population of ONE collection — split, because the gate and the
+ * operator ask two different questions and only one of them has to be cheap.
+ *
+ * `present` is the GATE: "is there at least one row that would be orphaned by a
+ * repoint". It is a single indexed seek to the first matching row, so it stays
+ * answerable on a saturated disk and answers in O(log n) precisely in the state
+ * that matters — after a seal, when the population is empty.
+ *
+ * `rows` is the NUMBER, for the refusal message and the operator's sense of
+ * scale. It is a second, indexed `COUNT(*)`, and `null` means **not
+ * measurable** — never zero. `{ present: true, rows: null }` is a legitimate
+ * and useful answer: "there are some, and this read could not say how many"
+ * still refuses the cutover, which is the whole job.
+ */
+export declare const UnstampedRowsSchema: z.ZodObject<{
+    present: z.ZodBoolean;
+    rows: z.ZodNullable<z.ZodNumber>;
 }, z.core.$strip>;
+export type UnstampedRows = z.infer<typeof UnstampedRowsSchema>;
+/**
+ * How many rows still carry NO `locationId` — the population a repoint would
+ * silently re-aim at a disk that does not hold their bytes.
+ *
+ * **`null` = the count could not be taken**, and it is NOT permission to cut
+ * over. The gate opens on a measured absence and on nothing else; an unread
+ * collection and an empty one are different facts, and this repo has already
+ * paid for conflating them (`RelocateResidueSchema`, D295).
+ */
+export declare const UnstampedEventMediaCountSchema: z.ZodNullable<z.ZodObject<{
+    media: z.ZodObject<{
+        present: z.ZodBoolean;
+        rows: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    retrainFrames: z.ZodObject<{
+        present: z.ZodBoolean;
+        rows: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    anyPresent: z.ZodBoolean;
+    total: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>>;
 export type UnstampedEventMediaCount = z.infer<typeof UnstampedEventMediaCountSchema>;
 export declare const StorageMigrationMediaMoveInputSchema: z.ZodObject<{
     toLocationId: z.ZodString;
@@ -249,6 +283,35 @@ export declare const StorageMigrationParticipantSchema: z.ZodEnum<{
     analytics: "analytics";
 }>;
 export type StorageMigrationParticipant = z.infer<typeof StorageMigrationParticipantSchema>;
+/**
+ * The mover's own numbers, folded onto the coordinator's durable move record.
+ *
+ * The long half of a non-blocking migration is `draining`, and it is measured
+ * in hours: 136 885 files at ~4 MB/s is about five of them. Before this shape
+ * existed the only place those numbers appeared was a Loki line, so an operator
+ * watching the Admin UI saw `phase: draining` and nothing else for a whole
+ * afternoon.
+ *
+ * It is POLLED, never pushed. Events are telemetry and may be dropped
+ * (D8/D11), and a dropped progress event is indistinguishable from a stalled
+ * mover — which is the exact failure this is meant to end. The coordinator's
+ * `waitForMoves` already fetches the whole {@link RelocateJob} on every tick to
+ * read `state`; folding the counters costs no extra read and makes the durable
+ * record say afterwards how far a move actually got.
+ *
+ * `filesTotal` is `null` for "no honest denominator" and is never zero-filled:
+ * a windowed footage job (`sinceMs`) and a node with no ledger both genuinely
+ * cannot say M, and a 0 there would render as "100 % done".
+ */
+export declare const StorageMigrationMoveProgressSchema: z.ZodObject<{
+    filesMoved: z.ZodNumber;
+    filesTotal: z.ZodNullable<z.ZodNumber>;
+    bytesMoved: z.ZodNumber;
+    rowsReconciled: z.ZodOptional<z.ZodNumber>;
+    startedAt: z.ZodNumber;
+    observedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type StorageMigrationMoveProgress = z.infer<typeof StorageMigrationMoveProgressSchema>;
 export declare const StorageMigrationMoveSchema: z.ZodObject<{
     storageClass: z.ZodEnum<{
         recordings: "recordings";
@@ -268,6 +331,14 @@ export declare const StorageMigrationMoveSchema: z.ZodObject<{
         cancelled: "cancelled";
     }>>;
     error: z.ZodNullable<z.ZodString>;
+    progress: z.ZodNullable<z.ZodObject<{
+        filesMoved: z.ZodNumber;
+        filesTotal: z.ZodNullable<z.ZodNumber>;
+        bytesMoved: z.ZodNumber;
+        rowsReconciled: z.ZodOptional<z.ZodNumber>;
+        startedAt: z.ZodNumber;
+        observedAt: z.ZodNumber;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type StorageMigrationMove = z.infer<typeof StorageMigrationMoveSchema>;
 export declare const StorageMigrationJobSchema: z.ZodObject<{
@@ -317,6 +388,14 @@ export declare const StorageMigrationJobSchema: z.ZodObject<{
             cancelled: "cancelled";
         }>>;
         error: z.ZodNullable<z.ZodString>;
+        progress: z.ZodNullable<z.ZodObject<{
+            filesMoved: z.ZodNumber;
+            filesTotal: z.ZodNullable<z.ZodNumber>;
+            bytesMoved: z.ZodNumber;
+            rowsReconciled: z.ZodOptional<z.ZodNumber>;
+            startedAt: z.ZodNumber;
+            observedAt: z.ZodNumber;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     pauseLeaseId: z.ZodNullable<z.ZodString>;
     pausedParticipants: z.ZodArray<z.ZodEnum<{
@@ -423,3 +502,143 @@ export declare const StorageMigrationPlanSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type StorageMigrationPlan = z.infer<typeof StorageMigrationPlanSchema>;
+/**
+ * Which single-flight engine owns a class of work.
+ *
+ * Shared rather than re-declared per consumer: the coordinator lanes its moves
+ * by it, and `storageMigration.movers` labels a mover with it so an operator
+ * can see *which* engine is busy when a drain refuses to start beside another.
+ */
+export declare const StorageMigrationLaneSchema: z.ZodEnum<{
+    media: "media";
+    footage: "footage";
+}>;
+export type StorageMigrationLane = z.infer<typeof StorageMigrationLaneSchema>;
+/**
+ * A mover as it exists RIGHT NOW, whether or not a migration job owns it.
+ *
+ * The coordinator's job record is the state of record for a migration, and its
+ * moves carry {@link StorageMigrationMoveProgress}. But the movers are usable
+ * standalone — `recording.relocateFootage` and `pipelineAnalytics.relocateMedia`
+ * are both operator-callable, and on 2026-08-29 a five-hour drain was armed that
+ * way because no supported UI path existed. A mover armed like that has no job
+ * to fold progress into, so it has to be readable on its own or it is invisible.
+ *
+ * `migrationJobId` is what tells the two apart: `null` means nothing here
+ * orchestrated it.
+ */
+export declare const StorageMigrationMoverSchema: z.ZodObject<{
+    lane: z.ZodEnum<{
+        media: "media";
+        footage: "footage";
+    }>;
+    job: z.ZodObject<{
+        jobId: z.ZodString;
+        state: z.ZodEnum<{
+            failed: "failed";
+            running: "running";
+            queued: "queued";
+            done: "done";
+            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>;
+        rowsReconciled: z.ZodOptional<z.ZodNumber>;
+        startedAt: z.ZodNumber;
+        finishedAt: z.ZodNullable<z.ZodNumber>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    migrationJobId: z.ZodNullable<z.ZodString>;
+    observedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type StorageMigrationMover = z.infer<typeof StorageMigrationMoverSchema>;
+/**
+ * What a SOURCE still holds for one storage class — the number that makes a
+ * "drain remaining" action honest rather than hopeful.
+ *
+ * It comes from the archive (`SegmentHourLedger.census` for footage, the media
+ * engine's own selection count for media), never from the resident index: a
+ * drain sized off `RecordingIndex` is what reported `done` over 80.3 GB it had
+ * never been told about (D295).
+ *
+ * `items`/`bytes` are `null` for "the archive could not be asked", which is
+ * deliberately NOT zero: a drain is still offered for an unknown residue,
+ * because refusing on an unanswerable read would hide exactly the case an
+ * operator needs to act on.
+ */
+export declare const StorageMigrationResidueSchema: z.ZodObject<{
+    storageClass: z.ZodEnum<{
+        recordings: "recordings";
+        recordingsLow: "recordingsLow";
+        eventMedia: "eventMedia";
+        backups: "backups";
+        galleryMedia: "galleryMedia";
+    }>;
+    fromLocationId: z.ZodString;
+    toLocationId: z.ZodString;
+    items: z.ZodNullable<z.ZodNumber>;
+    bytes: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type StorageMigrationResidue = z.infer<typeof StorageMigrationResidueSchema>;
+/**
+ * Run the DRAIN half and nothing else.
+ *
+ * A migration that reached `done` has already repointed, so `start` correctly
+ * refuses its destination ("already the default") — there is nothing left to
+ * repoint. But the drain can fail, be cancelled, be interrupted by a restart,
+ * or finish against a work list that was a tenth of the archive (D295), and
+ * before this there was no supported way to run only that half: the only way
+ * through was calling `recording.relocateFootage` by hand over admin tRPC.
+ *
+ * `drain` NEVER calls `setDefaultLocations`. That is what keeps `start`'s
+ * refusal meaningful: the two verbs are disjoint, so nothing here can silently
+ * re-repoint a class that is already migrated.
+ */
+export declare const StorageMigrationDrainInputSchema: z.ZodObject<{
+    classes: z.ZodArray<z.ZodEnum<{
+        recordings: "recordings";
+        recordingsLow: "recordingsLow";
+        eventMedia: "eventMedia";
+        backups: "backups";
+        galleryMedia: "galleryMedia";
+    }>>;
+    throttleMbps: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type StorageMigrationDrainInput = z.infer<typeof StorageMigrationDrainInputSchema>;
+/** What a footage source still holds, asked of the durable hour ledger. */
+export declare const RelocateResidueInputSchema: z.ZodObject<{
+    fromLocationId: z.ZodString;
+    footageClass: z.ZodOptional<z.ZodEnum<{
+        recordings: "recordings";
+        recordingsLow: "recordingsLow";
+    }>>;
+}, z.core.$strip>;
+export type RelocateResidueInput = z.infer<typeof RelocateResidueInputSchema>;
+/** `null` = the archive could not answer (no ledger on this node, or the
+ *  aggregate failed). Never conflated with an empty source. */
+export declare const RelocateResidueSchema: z.ZodNullable<z.ZodObject<{
+    segments: z.ZodNumber;
+    bytes: z.ZodNumber;
+}, z.core.$strip>>;
+export type RelocateResidue = z.infer<typeof RelocateResidueSchema>;
+/** How many rows a media pass would still act on against a given target — the
+ *  media lane's denominator AND its residue, from ONE derivation so the two can
+ *  never disagree. `null` = the count could not be taken. */
+export declare const RelocatableMediaCountSchema: z.ZodNullable<z.ZodObject<{
+    rows: z.ZodNumber;
+}, z.core.$strip>>;
+export type RelocatableMediaCount = z.infer<typeof RelocatableMediaCountSchema>;
+export declare const RelocatableMediaCountInputSchema: z.ZodObject<{
+    toLocationId: z.ZodString;
+    mode: z.ZodOptional<z.ZodEnum<{
+        move: "move";
+        seal: "seal";
+        gallery: "gallery";
+    }>>;
+}, z.core.$strip>;
+export type RelocatableMediaCountInput = z.infer<typeof RelocatableMediaCountInputSchema>;

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

@@ -19,6 +19,42 @@ import { z } from 'zod';
  *   two addons declaring the same `id` must agree on `cardinality` (validated
  *   at kernel aggregation time, not here).
  */
+/**
+ * `StorageAccess` — how the service that DECLARED a storage-location kind
+ * actually reaches the bytes. It is the constraint that decides which
+ * `storage-provider`s may back a location of that kind.
+ *
+ * - `'local-path'` — the service asks `storage.resolve` for a path string and
+ *   then does its own `node:fs` I/O on it (the recorder's segment writer, the
+ *   post-analysis media roots). Only a provider that serves a genuine local
+ *   filesystem (`getProviderInfo().nodeLocal === true`) can satisfy that: a
+ *   remote provider's `resolve` returns a path on the REMOTE host, and
+ *   `fs.readdir` of it on this node either fails or — far worse — succeeds
+ *   against a same-named local directory that is something else entirely.
+ *
+ * - `'cap-mediated'` — every byte travels through the `storage` cap
+ *   (`read`/`write`, or `beginUpload`/`writeChunk`/`finalizeUpload`). The
+ *   service never sees a path, so any provider can back it. `backups` is the
+ *   one kind that qualifies today.
+ *
+ * Before this existed, `recordings` was unreachable by SFTP/S3/WebDAV only as
+ * an EMERGENT property of how the recorder happened to be written. Nothing
+ * refused the configuration; the first write simply went somewhere wrong, and
+ * a recording write that goes wrong surfaces as a silent black window rather
+ * than an error (the read path does not `stat`). This turns that accident into
+ * a declared, enforced, testable refusal.
+ */
+export declare const StorageAccessSchema: z.ZodEnum<{
+    "local-path": "local-path";
+    "cap-mediated": "cap-mediated";
+}>;
+export type StorageAccess = z.infer<typeof StorageAccessSchema>;
+/**
+ * What an ABSENT `access` means. Fail-closed: a declaration that says nothing
+ * is treated as if it does raw filesystem I/O, so a remote provider is
+ * refused for it. The permissive value must be written down.
+ */
+export declare const STORAGE_ACCESS_FALLBACK: StorageAccess;
 export declare const StorageLocationDeclarationSchema: z.ZodObject<{
     id: z.ZodString;
     displayName: z.ZodString;
@@ -27,6 +63,10 @@ export declare const StorageLocationDeclarationSchema: z.ZodObject<{
         single: "single";
         multi: "multi";
     }>;
+    access: z.ZodOptional<z.ZodEnum<{
+        "local-path": "local-path";
+        "cap-mediated": "cap-mediated";
+    }>>;
     defaultsTo: z.ZodOptional<z.ZodString>;
     defaultRoot: z.ZodOptional<z.ZodEnum<{
         data: "data";

package/dist/{sleep-CJrvRDlD.js → sleep-CWWLTM6W.js}

@@ -3446,6 +3446,7 @@ function createDeviceProxy(api, binding, opts) {
 			cancelStorageMigrationMove: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "cancelStorageMigrationMove", "mutation", input),
 			relocateMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "relocateMedia", "mutation", input),
 			countUnstampedEventMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "countUnstampedEventMedia", "query", input),
+			countRelocatableMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "countRelocatableMedia", "query", input),
 			listRelocateMediaJobs: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listRelocateMediaJobs", "query", input),
 			cancelRelocateMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "cancelRelocateMedia", "mutation", input),
 			listOpsLog: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listOpsLog", "query", input),

package/dist/{sleep-L5-bG_a_.mjs → sleep-bm0x6zZF.mjs}

@@ -3446,6 +3446,7 @@ function createDeviceProxy(api, binding, opts) {
 			cancelStorageMigrationMove: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "cancelStorageMigrationMove", "mutation", input),
 			relocateMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "relocateMedia", "mutation", input),
 			countUnstampedEventMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "countUnstampedEventMedia", "query", input),
+			countRelocatableMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "countRelocatableMedia", "query", input),
 			listRelocateMediaJobs: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listRelocateMediaJobs", "query", input),
 			cancelRelocateMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "cancelRelocateMedia", "mutation", input),
 			listOpsLog: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listOpsLog", "query", input),

package/package.json

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