@camstack/types 1.2.328 → 1.2.329

package/dist/capabilities/pipeline-analytics.cap.d.ts

@@ -1351,6 +1351,7 @@ export declare const RetrainExportFilterSchema: z.ZodObject<{
     deviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
     frameIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     collectionIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    datasetVersionId: z.ZodOptional<z.ZodString>;
     batchId: z.ZodOptional<z.ZodString>;
     completeOnly: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
@@ -1716,6 +1717,136 @@ export declare const RetrainLlmAssistResultSchema: z.ZodDiscriminatedUnion<[z.Zo
     detail: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>], "kind">;
 export type RetrainLlmAssistResult = z.infer<typeof RetrainLlmAssistResultSchema>;
+/** What a dataset version is cut from. Every field narrows. */
+export declare const RetrainDatasetSelectionSchema: z.ZodObject<{
+    deviceIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodNumber>>>;
+    collectionIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    frameIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type RetrainDatasetSelection = z.infer<typeof RetrainDatasetSelectionSchema>;
+/** The counts a dataset is judged by. */
+export declare const RetrainDatasetStatsSchema: z.ZodObject<{
+    frames: z.ZodNumber;
+    completeFrames: z.ZodNumber;
+    completeness: z.ZodNumber;
+    subjects: z.ZodNumber;
+    modelErrors: z.ZodNumber;
+    hardNegatives: z.ZodNumber;
+    cells: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        macroClass: z.ZodString;
+        deviceId: z.ZodNumber;
+        lighting: z.ZodEnum<{
+            unknown: "unknown";
+            day: "day";
+            night: "night";
+        }>;
+        subjects: z.ZodNumber;
+        frames: z.ZodNumber;
+    }, z.core.$strip>>>;
+    cameras: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        deviceId: z.ZodNumber;
+        frames: z.ZodNumber;
+        completeFrames: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type RetrainDatasetStats = z.infer<typeof RetrainDatasetStatsSchema>;
+/** An immutable dataset version, without its frame list. */
+export declare const RetrainDatasetVersionSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    createdAt: z.ZodNumber;
+    selection: z.ZodObject<{
+        deviceIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodNumber>>>;
+        collectionIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        frameIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>;
+    layout: z.ZodEnum<{
+        frames: "frames";
+        crops: "crops";
+    }>;
+    completeOnly: z.ZodBoolean;
+    frameCount: z.ZodNumber;
+    annotationHash: z.ZodString;
+    manifestSchema: z.ZodString;
+    stats: z.ZodObject<{
+        frames: z.ZodNumber;
+        completeFrames: z.ZodNumber;
+        completeness: z.ZodNumber;
+        subjects: z.ZodNumber;
+        modelErrors: z.ZodNumber;
+        hardNegatives: z.ZodNumber;
+        cells: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            macroClass: z.ZodString;
+            deviceId: z.ZodNumber;
+            lighting: z.ZodEnum<{
+                unknown: "unknown";
+                day: "day";
+                night: "night";
+            }>;
+            subjects: z.ZodNumber;
+            frames: z.ZodNumber;
+        }, z.core.$strip>>>;
+        cameras: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            frames: z.ZodNumber;
+            completeFrames: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type RetrainDatasetVersion = z.infer<typeof RetrainDatasetVersionSchema>;
+export declare const CreateRetrainDatasetVersionResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"created">;
+    version: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        createdAt: z.ZodNumber;
+        selection: z.ZodObject<{
+            deviceIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodNumber>>>;
+            collectionIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            frameIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>;
+        layout: z.ZodEnum<{
+            frames: "frames";
+            crops: "crops";
+        }>;
+        completeOnly: z.ZodBoolean;
+        frameCount: z.ZodNumber;
+        annotationHash: z.ZodString;
+        manifestSchema: z.ZodString;
+        stats: z.ZodObject<{
+            frames: z.ZodNumber;
+            completeFrames: z.ZodNumber;
+            completeness: z.ZodNumber;
+            subjects: z.ZodNumber;
+            modelErrors: z.ZodNumber;
+            hardNegatives: z.ZodNumber;
+            cells: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                macroClass: z.ZodString;
+                deviceId: z.ZodNumber;
+                lighting: z.ZodEnum<{
+                    unknown: "unknown";
+                    day: "day";
+                    night: "night";
+                }>;
+                subjects: z.ZodNumber;
+                frames: z.ZodNumber;
+            }, z.core.$strip>>>;
+            cameras: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                deviceId: z.ZodNumber;
+                frames: z.ZodNumber;
+                completeFrames: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"refused">;
+    reason: z.ZodEnum<{
+        "empty-name": "empty-name";
+        "duplicate-name": "duplicate-name";
+        "no-frames": "no-frames";
+    }>;
+}, z.core.$strip>], "kind">;
+export type CreateRetrainDatasetVersionResult = z.infer<typeof CreateRetrainDatasetVersionResultSchema>;
 /** The outcome of a lifecycle move owned by the retrain page. */
 export declare const RetrainTransitionResultSchema: z.ZodObject<{
     trackId: z.ZodString;
@@ -4605,6 +4736,7 @@ export declare const pipelineAnalyticsCapability: {
             deviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
             frameIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
             collectionIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            datasetVersionId: z.ZodOptional<z.ZodString>;
             batchId: z.ZodOptional<z.ZodString>;
             completeOnly: z.ZodOptional<z.ZodBoolean>;
             layout: z.ZodOptional<z.ZodEnum<{
@@ -4698,6 +4830,7 @@ export declare const pipelineAnalyticsCapability: {
                 deviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 frameIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 collectionIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                datasetVersionId: z.ZodOptional<z.ZodString>;
                 batchId: z.ZodOptional<z.ZodString>;
                 completeOnly: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>;
@@ -4724,6 +4857,168 @@ export declare const pipelineAnalyticsCapability: {
             sha256: z.ZodString;
             status: z.ZodNumber;
         }, z.core.$strip>, "mutation">;
+        /** The counts a selection would freeze — class × camera × day/night,
+         *  completeness — without freezing anything. Index reads only. */
+        readonly previewRetrainDataset: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            selection: z.ZodObject<{
+                deviceIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodNumber>>>;
+                collectionIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+                frameIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strip>;
+            completeOnly: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            frames: z.ZodNumber;
+            completeFrames: z.ZodNumber;
+            completeness: z.ZodNumber;
+            subjects: z.ZodNumber;
+            modelErrors: z.ZodNumber;
+            hardNegatives: z.ZodNumber;
+            cells: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                macroClass: z.ZodString;
+                deviceId: z.ZodNumber;
+                lighting: z.ZodEnum<{
+                    unknown: "unknown";
+                    day: "day";
+                    night: "night";
+                }>;
+                subjects: z.ZodNumber;
+                frames: z.ZodNumber;
+            }, z.core.$strip>>>;
+            cameras: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                deviceId: z.ZodNumber;
+                frames: z.ZodNumber;
+                completeFrames: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, "query">;
+        /**
+         * Freeze a dataset version: the frames the selection yields (the same plan
+         * the annotated export builds), the hash of what they teach, the export
+         * parameters and the counts. Immutable — a different selection is a new
+         * version. Export it with `getRetrainExportUrl({ datasetVersionId })`.
+         */
+        readonly createRetrainDatasetVersion: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            name: z.ZodString;
+            selection: z.ZodObject<{
+                deviceIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodNumber>>>;
+                collectionIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+                frameIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strip>;
+            layout: z.ZodEnum<{
+                frames: "frames";
+                crops: "crops";
+            }>;
+            completeOnly: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"created">;
+            version: z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                createdAt: z.ZodNumber;
+                selection: z.ZodObject<{
+                    deviceIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodNumber>>>;
+                    collectionIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+                    frameIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+                }, z.core.$strip>;
+                layout: z.ZodEnum<{
+                    frames: "frames";
+                    crops: "crops";
+                }>;
+                completeOnly: z.ZodBoolean;
+                frameCount: z.ZodNumber;
+                annotationHash: z.ZodString;
+                manifestSchema: z.ZodString;
+                stats: z.ZodObject<{
+                    frames: z.ZodNumber;
+                    completeFrames: z.ZodNumber;
+                    completeness: z.ZodNumber;
+                    subjects: z.ZodNumber;
+                    modelErrors: z.ZodNumber;
+                    hardNegatives: z.ZodNumber;
+                    cells: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                        macroClass: z.ZodString;
+                        deviceId: z.ZodNumber;
+                        lighting: z.ZodEnum<{
+                            unknown: "unknown";
+                            day: "day";
+                            night: "night";
+                        }>;
+                        subjects: z.ZodNumber;
+                        frames: z.ZodNumber;
+                    }, z.core.$strip>>>;
+                    cameras: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                        deviceId: z.ZodNumber;
+                        frames: z.ZodNumber;
+                        completeFrames: z.ZodNumber;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"refused">;
+            reason: z.ZodEnum<{
+                "empty-name": "empty-name";
+                "duplicate-name": "duplicate-name";
+                "no-frames": "no-frames";
+            }>;
+        }, z.core.$strip>], "kind">, "mutation">;
+        /** Every dataset version, newest first. */
+        readonly listRetrainDatasetVersions: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            createdAt: z.ZodNumber;
+            selection: z.ZodObject<{
+                deviceIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodNumber>>>;
+                collectionIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+                frameIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strip>;
+            layout: z.ZodEnum<{
+                frames: "frames";
+                crops: "crops";
+            }>;
+            completeOnly: z.ZodBoolean;
+            frameCount: z.ZodNumber;
+            annotationHash: z.ZodString;
+            manifestSchema: z.ZodString;
+            stats: z.ZodObject<{
+                frames: z.ZodNumber;
+                completeFrames: z.ZodNumber;
+                completeness: z.ZodNumber;
+                subjects: z.ZodNumber;
+                modelErrors: z.ZodNumber;
+                hardNegatives: z.ZodNumber;
+                cells: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    macroClass: z.ZodString;
+                    deviceId: z.ZodNumber;
+                    lighting: z.ZodEnum<{
+                        unknown: "unknown";
+                        day: "day";
+                        night: "night";
+                    }>;
+                    subjects: z.ZodNumber;
+                    frames: z.ZodNumber;
+                }, z.core.$strip>>>;
+                cameras: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    deviceId: z.ZodNumber;
+                    frames: z.ZodNumber;
+                    completeFrames: z.ZodNumber;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>>, "query">;
+        /** Delete a version. Its frames stay in the dataset. */
+        readonly deleteRetrainDatasetVersion: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            deleted: z.ZodBoolean;
+        }, z.core.$strip>, "mutation">;
+        /** Does the corpus still teach what the version froze? `missingFrames`
+         *  counts frames that left the dataset (or lost every box and tick). */
+        readonly verifyRetrainDatasetVersion: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            found: z.ZodBoolean;
+            annotationHash: z.ZodString;
+            matches: z.ZodBoolean;
+            missingFrames: z.ZodNumber;
+        }, z.core.$strip>, "query">;
         /** The enabled, vision-capable LLM profiles, each saying whether a frame
          *  sent to it leaves the house. */
         readonly listRetrainAssistProfiles: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{

package/dist/client.js

@@ -5754,6 +5754,11 @@ function createDeviceProxy(api, binding, opts) {
 		getRetrainExportUrl: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getRetrainExportUrl", "query", input),
 		setRetrainFrameComplete: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "setRetrainFrameComplete", "mutation", input),
 		writeRetrainArchive: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "writeRetrainArchive", "mutation", input),
+		previewRetrainDataset: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "previewRetrainDataset", "query", input),
+		createRetrainDatasetVersion: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "createRetrainDatasetVersion", "mutation", input),
+		listRetrainDatasetVersions: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listRetrainDatasetVersions", "query", input),
+		deleteRetrainDatasetVersion: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "deleteRetrainDatasetVersion", "mutation", input),
+		verifyRetrainDatasetVersion: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "verifyRetrainDatasetVersion", "query", input),
 		listRetrainAssistProfiles: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listRetrainAssistProfiles", "query", input),
 		proposeRetrainAnnotationsWithLlm: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "proposeRetrainAnnotationsWithLlm", "mutation", input),
 		createRetrainCollection: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "createRetrainCollection", "mutation", input),

package/dist/client.mjs

@@ -5753,6 +5753,11 @@ function createDeviceProxy(api, binding, opts) {
 		getRetrainExportUrl: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getRetrainExportUrl", "query", input),
 		setRetrainFrameComplete: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "setRetrainFrameComplete", "mutation", input),
 		writeRetrainArchive: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "writeRetrainArchive", "mutation", input),
+		previewRetrainDataset: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "previewRetrainDataset", "query", input),
+		createRetrainDatasetVersion: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "createRetrainDatasetVersion", "mutation", input),
+		listRetrainDatasetVersions: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listRetrainDatasetVersions", "query", input),
+		deleteRetrainDatasetVersion: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "deleteRetrainDatasetVersion", "mutation", input),
+		verifyRetrainDatasetVersion: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "verifyRetrainDatasetVersion", "query", input),
 		listRetrainAssistProfiles: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listRetrainAssistProfiles", "query", input),
 		proposeRetrainAnnotationsWithLlm: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "proposeRetrainAnnotationsWithLlm", "mutation", input),
 		createRetrainCollection: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "createRetrainCollection", "mutation", input),

package/dist/generated/addon-api.d.ts

@@ -6051,6 +6051,41 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof pipelineAnalyticsCapability.methods.writeRetrainArchive.output>;
             meta: object;
         }>;
+        previewRetrainDataset: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.previewRetrainDataset.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.previewRetrainDataset.output>;
+            meta: object;
+        }>;
+        createRetrainDatasetVersion: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.createRetrainDatasetVersion.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.createRetrainDatasetVersion.output>;
+            meta: object;
+        }>;
+        listRetrainDatasetVersions: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.listRetrainDatasetVersions.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.listRetrainDatasetVersions.output>;
+            meta: object;
+        }>;
+        deleteRetrainDatasetVersion: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.deleteRetrainDatasetVersion.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.deleteRetrainDatasetVersion.output>;
+            meta: object;
+        }>;
+        verifyRetrainDatasetVersion: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.verifyRetrainDatasetVersion.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.verifyRetrainDatasetVersion.output>;
+            meta: object;
+        }>;
         listRetrainAssistProfiles: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;

package/dist/generated/method-access-map.d.ts

@@ -6,7 +6,7 @@
  * scope+access check inside `protectedProcedure` (see
  * `server/backend/src/api/trpc/trpc.middleware.ts`).
  *
- * Coverage: 1253 method paths across 167 capabilities.
+ * Coverage: 1258 method paths across 167 capabilities.
  */
 import type { CapabilityMethodAccess } from '../capabilities/capability-definition.js';
 export interface MethodAccessRecord {

package/dist/index.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-i3kl-0Na.js");
+const require_sleep = require("./sleep-ClNXPpWR.js");
 const require_event_category = require("./event-category-CHduMGvg.js");
 const require_composition = require("./composition-BLWAivB2.js");
 const require_err_msg = require("./err-msg-Dx2Kor0g.js");
@@ -25091,6 +25091,9 @@ var RetrainExportFilterSchema = zod.z.object({
 	frameIds: zod.z.array(zod.z.string()).max(2e4).optional(),
 	/** Only frames in at least one of these named collections. */
 	collectionIds: zod.z.array(zod.z.string()).max(200).optional(),
+	/** Exactly the frames of this dataset version (and its completeOnly). An
+	*  unknown id selects nothing. */
+	datasetVersionId: zod.z.string().optional(),
 	batchId: zod.z.string().optional(),
 	/** Only frames the operator marked complete (all subjects boxed). */
 	completeOnly: zod.z.boolean().optional()
@@ -25258,6 +25261,67 @@ var RetrainLlmAssistResultSchema = zod.z.discriminatedUnion("kind", [zod.z.objec
 	]),
 	detail: zod.z.string().optional()
 })]);
+/** What a dataset version is cut from. Every field narrows. */
+var RetrainDatasetSelectionSchema = zod.z.object({
+	deviceIds: zod.z.array(zod.z.number()).readonly().optional(),
+	collectionIds: zod.z.array(zod.z.string()).max(200).readonly().optional(),
+	frameIds: zod.z.array(zod.z.string()).max(2e4).readonly().optional()
+});
+/** The counts a dataset is judged by. */
+var RetrainDatasetStatsSchema = zod.z.object({
+	frames: zod.z.number().int(),
+	completeFrames: zod.z.number().int(),
+	/** `completeFrames / frames`, 0..1. */
+	completeness: zod.z.number(),
+	/** Boxes to learn (model errors excluded). */
+	subjects: zod.z.number().int(),
+	modelErrors: zod.z.number().int(),
+	/** Complete frames with no subject. */
+	hardNegatives: zod.z.number().int(),
+	/** Subjects per class × camera × day/night. */
+	cells: zod.z.array(zod.z.object({
+		macroClass: zod.z.string(),
+		deviceId: zod.z.number(),
+		lighting: zod.z.enum([
+			"day",
+			"night",
+			"unknown"
+		]),
+		subjects: zod.z.number().int(),
+		frames: zod.z.number().int()
+	})).readonly(),
+	cameras: zod.z.array(zod.z.object({
+		deviceId: zod.z.number(),
+		frames: zod.z.number().int(),
+		completeFrames: zod.z.number().int()
+	})).readonly()
+});
+/** An immutable dataset version, without its frame list. */
+var RetrainDatasetVersionSchema = zod.z.object({
+	id: zod.z.string(),
+	name: zod.z.string(),
+	createdAt: zod.z.number(),
+	selection: RetrainDatasetSelectionSchema,
+	layout: RetrainExportLayoutSchema,
+	completeOnly: zod.z.boolean(),
+	frameCount: zod.z.number().int(),
+	/** sha256 of what the frames taught when the version was frozen. */
+	annotationHash: zod.z.string(),
+	/** The export manifest schema the version was cut under. */
+	manifestSchema: zod.z.string(),
+	stats: RetrainDatasetStatsSchema
+});
+var CreateRetrainDatasetVersionResultSchema = zod.z.discriminatedUnion("kind", [zod.z.object({
+	kind: zod.z.literal("created"),
+	version: RetrainDatasetVersionSchema
+}), zod.z.object({
+	kind: zod.z.literal("refused"),
+	reason: zod.z.enum([
+		"empty-name",
+		"duplicate-name",
+		"no-frames"
+	])
+})]);
 /** The outcome of a lifecycle move owned by the retrain page. */
 var RetrainTransitionResultSchema = zod.z.object({
 	trackId: zod.z.string(),
@@ -26657,6 +26721,53 @@ var pipelineAnalyticsCapability = {
 			auth: "admin",
 			timeoutMs: 60 * 6e4
 		}),
+		/** The counts a selection would freeze — class × camera × day/night,
+		*  completeness — without freezing anything. Index reads only. */
+		previewRetrainDataset: require_sleep.method(zod.z.object({
+			selection: RetrainDatasetSelectionSchema,
+			completeOnly: zod.z.boolean().optional()
+		}), RetrainDatasetStatsSchema, {
+			kind: "query",
+			auth: "admin"
+		}),
+		/**
+		* Freeze a dataset version: the frames the selection yields (the same plan
+		* the annotated export builds), the hash of what they teach, the export
+		* parameters and the counts. Immutable — a different selection is a new
+		* version. Export it with `getRetrainExportUrl({ datasetVersionId })`.
+		*/
+		createRetrainDatasetVersion: require_sleep.method(zod.z.object({
+			name: zod.z.string().max(120),
+			selection: RetrainDatasetSelectionSchema,
+			layout: RetrainExportLayoutSchema,
+			completeOnly: zod.z.boolean()
+		}), CreateRetrainDatasetVersionResultSchema, {
+			kind: "mutation",
+			auth: "admin",
+			timeoutMs: 12e4
+		}),
+		/** Every dataset version, newest first. */
+		listRetrainDatasetVersions: require_sleep.method(zod.z.object({}), zod.z.array(RetrainDatasetVersionSchema).readonly(), {
+			kind: "query",
+			auth: "admin"
+		}),
+		/** Delete a version. Its frames stay in the dataset. */
+		deleteRetrainDatasetVersion: require_sleep.method(zod.z.object({ id: zod.z.string() }), zod.z.object({ deleted: zod.z.boolean() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Does the corpus still teach what the version froze? `missingFrames`
+		*  counts frames that left the dataset (or lost every box and tick). */
+		verifyRetrainDatasetVersion: require_sleep.method(zod.z.object({ id: zod.z.string() }), zod.z.object({
+			found: zod.z.boolean(),
+			annotationHash: zod.z.string(),
+			matches: zod.z.boolean(),
+			missingFrames: zod.z.number().int()
+		}), {
+			kind: "query",
+			auth: "admin",
+			timeoutMs: 12e4
+		}),
 		/** The enabled, vision-capable LLM profiles, each saying whether a frame
 		*  sent to it leaves the house. */
 		listRetrainAssistProfiles: require_sleep.method(zod.z.object({}), zod.z.array(RetrainAssistProfileSchema).readonly(), {
@@ -56878,6 +56989,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.createRetrainDatasetVersion": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.deleteDeviceEvents": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -56890,6 +57007,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"pipelineAnalytics.deleteRetrainDatasetVersion": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "delete"
+	},
 	"pipelineAnalytics.deleteTracks": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -57112,6 +57235,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.listRetrainDatasetVersions": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.listRetrainFrames": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -57154,6 +57283,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.previewRetrainDataset": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.proposeRetrainAnnotations": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -57292,6 +57427,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.verifyRetrainDatasetVersion": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.wipeAllAnalytics": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -77588,6 +77729,7 @@ exports.CoverStatusSchema = CoverStatusSchema;
 exports.CreateApiKeyInputSchema = CreateApiKeyInputSchema;
 exports.CreateApiKeyResultSchema = CreateApiKeyResultSchema;
 exports.CreateIntegrationInputSchema = CreateIntegrationInputSchema;
+exports.CreateRetrainDatasetVersionResultSchema = CreateRetrainDatasetVersionResultSchema;
 exports.CreateScopedTokenInputSchema = CreateScopedTokenInputSchema;
 exports.CreateScopedTokenResultSchema = CreateScopedTokenResultSchema;
 exports.CreateUserInputSchema = CreateUserInputSchema;
@@ -78546,6 +78688,9 @@ exports.RetrainCollectionCreateResultSchema = RetrainCollectionCreateResultSchem
 exports.RetrainCollectionRenameResultSchema = RetrainCollectionRenameResultSchema;
 exports.RetrainCollectionSchema = RetrainCollectionSchema;
 exports.RetrainCopyRefusalSchema = RetrainCopyRefusalSchema;
+exports.RetrainDatasetSelectionSchema = RetrainDatasetSelectionSchema;
+exports.RetrainDatasetStatsSchema = RetrainDatasetStatsSchema;
+exports.RetrainDatasetVersionSchema = RetrainDatasetVersionSchema;
 exports.RetrainExportFilterSchema = RetrainExportFilterSchema;
 exports.RetrainExportLayoutSchema = RetrainExportLayoutSchema;
 exports.RetrainFrameCandidateSchema = RetrainFrameCandidateSchema;