@camstack/types 1.2.335 → 1.2.337

package/dist/interfaces/relocate.d.ts

@@ -16,21 +16,21 @@ import { z } from 'zod';
  * runs at all.
  */
 export declare const RelocateJobStateSchema: z.ZodEnum<{
-    queued: "queued";
-    running: "running";
+    cancelled: "cancelled";
     done: "done";
     failed: "failed";
-    cancelled: "cancelled";
+    queued: "queued";
+    running: "running";
 }>;
 export type RelocateJobState = z.infer<typeof RelocateJobStateSchema>;
 export declare const RelocateJobSchema: z.ZodObject<{
     jobId: z.ZodString;
     state: z.ZodEnum<{
-        queued: "queued";
-        running: "running";
+        cancelled: "cancelled";
         done: "done";
         failed: "failed";
-        cancelled: "cancelled";
+        queued: "queued";
+        running: "running";
     }>;
     fromLocationId: z.ZodString;
     toLocationId: z.ZodString;
@@ -115,9 +115,9 @@ export type StorageMigrationFootageMoveInput = z.infer<typeof StorageMigrationFo
  *                is a few KB per enrolled sample.
  */
 export declare const MediaRelocateModeSchema: z.ZodEnum<{
+    gallery: "gallery";
     move: "move";
     seal: "seal";
-    gallery: "gallery";
 }>;
 export type MediaRelocateMode = z.infer<typeof MediaRelocateModeSchema>;
 export declare const RelocateMediaInputSchema: z.ZodObject<{
@@ -125,9 +125,9 @@ export declare const RelocateMediaInputSchema: z.ZodObject<{
     fromLocationId: z.ZodOptional<z.ZodString>;
     throttleMbps: z.ZodOptional<z.ZodNumber>;
     mode: z.ZodOptional<z.ZodEnum<{
+        gallery: "gallery";
         move: "move";
         seal: "seal";
-        gallery: "gallery";
     }>>;
 }, z.core.$strip>;
 export type RelocateMediaInput = z.infer<typeof RelocateMediaInputSchema>;
@@ -178,9 +178,9 @@ export declare const StorageMigrationMediaMoveInputSchema: z.ZodObject<{
     fromLocationId: z.ZodOptional<z.ZodString>;
     throttleMbps: z.ZodOptional<z.ZodNumber>;
     mode: z.ZodOptional<z.ZodEnum<{
+        gallery: "gallery";
         move: "move";
         seal: "seal";
-        gallery: "gallery";
     }>>;
     leaseId: z.ZodString;
 }, z.core.$strip>;
@@ -194,11 +194,11 @@ export type StorageMigrationMediaMoveInput = z.infer<typeof StorageMigrationMedi
  * enrolled gallery; `backups` is the system backup archive. The last two have
  * their own rules — see {@link StorageMigrationFindingCodeSchema}. */
 export declare const StorageMigrationClassSchema: z.ZodEnum<{
-    recordings: "recordings";
-    recordingsLow: "recordingsLow";
-    eventMedia: "eventMedia";
     backups: "backups";
+    eventMedia: "eventMedia";
     galleryMedia: "galleryMedia";
+    recordings: "recordings";
+    recordingsLow: "recordingsLow";
 }>;
 export type StorageMigrationClass = z.infer<typeof StorageMigrationClassSchema>;
 /** A destination is always an existing, fully-qualified location id. The
@@ -287,24 +287,24 @@ export type StorageMigrationInput = z.infer<typeof StorageMigrationInputSchema>;
  * `repointing` is still the only phase that changes a default location.
  */
 export declare const StorageMigrationPhaseSchema: z.ZodEnum<{
+    cancelled: "cancelled";
     done: "done";
+    draining: "draining";
     failed: "failed";
-    cancelled: "cancelled";
-    planning: "planning";
-    sealing: "sealing";
-    pausing: "pausing";
     moving: "moving";
-    draining: "draining";
-    verifying: "verifying";
-    repointing: "repointing";
+    pausing: "pausing";
+    planning: "planning";
     refreshing: "refreshing";
+    repointing: "repointing";
     resuming: "resuming";
+    sealing: "sealing";
+    verifying: "verifying";
 }>;
 export type StorageMigrationPhase = z.infer<typeof StorageMigrationPhaseSchema>;
 export declare const StorageMigrationParticipantSchema: z.ZodEnum<{
+    analytics: "analytics";
     pipeline: "pipeline";
     recorder: "recorder";
-    analytics: "analytics";
 }>;
 export type StorageMigrationParticipant = z.infer<typeof StorageMigrationParticipantSchema>;
 /**
@@ -338,22 +338,22 @@ export declare const StorageMigrationMoveProgressSchema: z.ZodObject<{
 export type StorageMigrationMoveProgress = z.infer<typeof StorageMigrationMoveProgressSchema>;
 export declare const StorageMigrationMoveSchema: z.ZodObject<{
     storageClass: z.ZodEnum<{
-        recordings: "recordings";
-        recordingsLow: "recordingsLow";
-        eventMedia: "eventMedia";
         backups: "backups";
+        eventMedia: "eventMedia";
         galleryMedia: "galleryMedia";
+        recordings: "recordings";
+        recordingsLow: "recordingsLow";
     }>;
     fromLocationId: z.ZodString;
     toLocationId: z.ZodString;
     freezeSource: z.ZodOptional<z.ZodBoolean>;
     moverJobId: z.ZodNullable<z.ZodString>;
     state: z.ZodNullable<z.ZodEnum<{
-        queued: "queued";
-        running: "running";
+        cancelled: "cancelled";
         done: "done";
         failed: "failed";
-        cancelled: "cancelled";
+        queued: "queued";
+        running: "running";
     }>>;
     error: z.ZodNullable<z.ZodString>;
     progress: z.ZodNullable<z.ZodObject<{
@@ -369,18 +369,18 @@ export type StorageMigrationMove = z.infer<typeof StorageMigrationMoveSchema>;
 export declare const StorageMigrationJobSchema: z.ZodObject<{
     jobId: z.ZodString;
     phase: z.ZodEnum<{
+        cancelled: "cancelled";
         done: "done";
+        draining: "draining";
         failed: "failed";
-        cancelled: "cancelled";
-        planning: "planning";
-        sealing: "sealing";
-        pausing: "pausing";
         moving: "moving";
-        draining: "draining";
-        verifying: "verifying";
-        repointing: "repointing";
+        pausing: "pausing";
+        planning: "planning";
         refreshing: "refreshing";
+        repointing: "repointing";
         resuming: "resuming";
+        sealing: "sealing";
+        verifying: "verifying";
     }>;
     mode: z.ZodEnum<{
         blocking: "blocking";
@@ -403,22 +403,22 @@ export declare const StorageMigrationJobSchema: z.ZodObject<{
     throttleMbps: z.ZodNumber;
     moves: z.ZodArray<z.ZodObject<{
         storageClass: z.ZodEnum<{
-            recordings: "recordings";
-            recordingsLow: "recordingsLow";
-            eventMedia: "eventMedia";
             backups: "backups";
+            eventMedia: "eventMedia";
             galleryMedia: "galleryMedia";
+            recordings: "recordings";
+            recordingsLow: "recordingsLow";
         }>;
         fromLocationId: z.ZodString;
         toLocationId: z.ZodString;
         freezeSource: z.ZodOptional<z.ZodBoolean>;
         moverJobId: z.ZodNullable<z.ZodString>;
         state: z.ZodNullable<z.ZodEnum<{
-            queued: "queued";
-            running: "running";
+            cancelled: "cancelled";
             done: "done";
             failed: "failed";
-            cancelled: "cancelled";
+            queued: "queued";
+            running: "running";
         }>>;
         error: z.ZodNullable<z.ZodString>;
         progress: z.ZodNullable<z.ZodObject<{
@@ -432,9 +432,9 @@ export declare const StorageMigrationJobSchema: z.ZodObject<{
     }, z.core.$strip>>;
     pauseLeaseId: z.ZodNullable<z.ZodString>;
     pausedParticipants: z.ZodArray<z.ZodEnum<{
+        analytics: "analytics";
         pipeline: "pipeline";
         recorder: "recorder";
-        analytics: "analytics";
     }>>;
     repointed: z.ZodBoolean;
     cancelRequested: z.ZodBoolean;
@@ -468,27 +468,27 @@ export type StorageMigrationJob = z.infer<typeof StorageMigrationJobSchema>;
  *    for it. The migration cannot move its bytes.
  */
 export declare const StorageMigrationFindingCodeSchema: z.ZodEnum<{
-    sharesDeviceWithSource: "sharesDeviceWithSource";
-    deviceIdentityUnknown: "deviceIdentityUnknown";
-    unstampedEventMediaRows: "unstampedEventMediaRows";
     blockingOnly: "blockingOnly";
+    deviceIdentityUnknown: "deviceIdentityUnknown";
     noMover: "noMover";
+    sharesDeviceWithSource: "sharesDeviceWithSource";
+    unstampedEventMediaRows: "unstampedEventMediaRows";
 }>;
 export type StorageMigrationFindingCode = z.infer<typeof StorageMigrationFindingCodeSchema>;
 export declare const StorageMigrationFindingSchema: z.ZodObject<{
     code: z.ZodEnum<{
-        sharesDeviceWithSource: "sharesDeviceWithSource";
-        deviceIdentityUnknown: "deviceIdentityUnknown";
-        unstampedEventMediaRows: "unstampedEventMediaRows";
         blockingOnly: "blockingOnly";
+        deviceIdentityUnknown: "deviceIdentityUnknown";
         noMover: "noMover";
+        sharesDeviceWithSource: "sharesDeviceWithSource";
+        unstampedEventMediaRows: "unstampedEventMediaRows";
     }>;
     storageClass: z.ZodEnum<{
-        recordings: "recordings";
-        recordingsLow: "recordingsLow";
-        eventMedia: "eventMedia";
         backups: "backups";
+        eventMedia: "eventMedia";
         galleryMedia: "galleryMedia";
+        recordings: "recordings";
+        recordingsLow: "recordingsLow";
     }>;
     message: z.ZodString;
 }, z.core.$strip>;
@@ -514,11 +514,11 @@ export declare const StorageMigrationPlanSchema: z.ZodObject<{
     }>;
     moves: z.ZodArray<z.ZodObject<{
         storageClass: z.ZodEnum<{
-            recordings: "recordings";
-            recordingsLow: "recordingsLow";
-            eventMedia: "eventMedia";
             backups: "backups";
+            eventMedia: "eventMedia";
             galleryMedia: "galleryMedia";
+            recordings: "recordings";
+            recordingsLow: "recordingsLow";
         }>;
         fromLocationId: z.ZodString;
         toLocationId: z.ZodString;
@@ -526,18 +526,18 @@ export declare const StorageMigrationPlanSchema: z.ZodObject<{
     }, z.core.$strip>>;
     findings: z.ZodArray<z.ZodObject<{
         code: z.ZodEnum<{
-            sharesDeviceWithSource: "sharesDeviceWithSource";
-            deviceIdentityUnknown: "deviceIdentityUnknown";
-            unstampedEventMediaRows: "unstampedEventMediaRows";
             blockingOnly: "blockingOnly";
+            deviceIdentityUnknown: "deviceIdentityUnknown";
             noMover: "noMover";
+            sharesDeviceWithSource: "sharesDeviceWithSource";
+            unstampedEventMediaRows: "unstampedEventMediaRows";
         }>;
         storageClass: z.ZodEnum<{
-            recordings: "recordings";
-            recordingsLow: "recordingsLow";
-            eventMedia: "eventMedia";
             backups: "backups";
+            eventMedia: "eventMedia";
             galleryMedia: "galleryMedia";
+            recordings: "recordings";
+            recordingsLow: "recordingsLow";
         }>;
         message: z.ZodString;
     }, z.core.$strip>>;
@@ -551,8 +551,8 @@ export type StorageMigrationPlan = z.infer<typeof StorageMigrationPlanSchema>;
  * can see *which* engine is busy when a drain refuses to start beside another.
  */
 export declare const StorageMigrationLaneSchema: z.ZodEnum<{
-    media: "media";
     footage: "footage";
+    media: "media";
 }>;
 export type StorageMigrationLane = z.infer<typeof StorageMigrationLaneSchema>;
 /**
@@ -570,17 +570,17 @@ export type StorageMigrationLane = z.infer<typeof StorageMigrationLaneSchema>;
  */
 export declare const StorageMigrationMoverSchema: z.ZodObject<{
     lane: z.ZodEnum<{
-        media: "media";
         footage: "footage";
+        media: "media";
     }>;
     job: z.ZodObject<{
         jobId: z.ZodString;
         state: z.ZodEnum<{
-            queued: "queued";
-            running: "running";
+            cancelled: "cancelled";
             done: "done";
             failed: "failed";
-            cancelled: "cancelled";
+            queued: "queued";
+            running: "running";
         }>;
         fromLocationId: z.ZodString;
         toLocationId: z.ZodString;
@@ -615,11 +615,11 @@ export type StorageMigrationMover = z.infer<typeof StorageMigrationMoverSchema>;
  */
 export declare const StorageMigrationResidueSchema: z.ZodObject<{
     storageClass: z.ZodEnum<{
-        recordings: "recordings";
-        recordingsLow: "recordingsLow";
-        eventMedia: "eventMedia";
         backups: "backups";
+        eventMedia: "eventMedia";
         galleryMedia: "galleryMedia";
+        recordings: "recordings";
+        recordingsLow: "recordingsLow";
     }>;
     fromLocationId: z.ZodString;
     toLocationId: z.ZodString;
@@ -643,11 +643,11 @@ export type StorageMigrationResidue = z.infer<typeof StorageMigrationResidueSche
  */
 export declare const StorageMigrationDrainInputSchema: z.ZodObject<{
     classes: z.ZodArray<z.ZodEnum<{
-        recordings: "recordings";
-        recordingsLow: "recordingsLow";
-        eventMedia: "eventMedia";
         backups: "backups";
+        eventMedia: "eventMedia";
         galleryMedia: "galleryMedia";
+        recordings: "recordings";
+        recordingsLow: "recordingsLow";
     }>>;
     throttleMbps: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
@@ -685,21 +685,21 @@ export declare const LedgerWalkInputSchema: z.ZodObject<{
 export type LedgerWalkInput = z.infer<typeof LedgerWalkInputSchema>;
 /** Why a whole walk did nothing. Every one leaves the ledger untouched. */
 export declare const LedgerWalkRefusalSchema: z.ZodEnum<{
-    "location-unknown": "location-unknown";
-    "source-writable": "source-writable";
-    "no-ledger": "no-ledger";
-    "archive-unreadable": "archive-unreadable";
     "anchor-absent": "anchor-absent";
-    "anchor-unreadable": "anchor-unreadable";
     "anchor-moved": "anchor-moved";
+    "anchor-unreadable": "anchor-unreadable";
+    "archive-unreadable": "archive-unreadable";
+    "location-unknown": "location-unknown";
+    "no-ledger": "no-ledger";
+    "source-writable": "source-writable";
 }>;
 export type LedgerWalkRefusal = z.infer<typeof LedgerWalkRefusalSchema>;
 /** Why one hour was left exactly as it was found. */
 export declare const LedgerWalkSkipReasonSchema: z.ZodEnum<{
-    "live-tail": "live-tail";
+    "durable-refused": "durable-refused";
     "listing-error": "listing-error";
+    "live-tail": "live-tail";
     "path-mismatch": "path-mismatch";
-    "durable-refused": "durable-refused";
 }>;
 export type LedgerWalkSkipReason = z.infer<typeof LedgerWalkSkipReasonSchema>;
 /** Every skip reason, always present, always a number — so a reason that never
@@ -734,13 +734,13 @@ export declare const LedgerWalkReportSchema: z.ZodObject<{
     locationId: z.ZodString;
     applied: z.ZodBoolean;
     refused: z.ZodNullable<z.ZodEnum<{
-        "location-unknown": "location-unknown";
-        "source-writable": "source-writable";
-        "no-ledger": "no-ledger";
-        "archive-unreadable": "archive-unreadable";
         "anchor-absent": "anchor-absent";
-        "anchor-unreadable": "anchor-unreadable";
         "anchor-moved": "anchor-moved";
+        "anchor-unreadable": "anchor-unreadable";
+        "archive-unreadable": "archive-unreadable";
+        "location-unknown": "location-unknown";
+        "no-ledger": "no-ledger";
+        "source-writable": "source-writable";
     }>>;
     archiveSegments: z.ZodNullable<z.ZodNumber>;
     archiveBytes: z.ZodNullable<z.ZodNumber>;
@@ -786,9 +786,9 @@ export declare const RelocatableMediaCountInputSchema: z.ZodObject<{
     toLocationId: z.ZodString;
     fromLocationId: z.ZodOptional<z.ZodString>;
     mode: z.ZodOptional<z.ZodEnum<{
+        gallery: "gallery";
         move: "move";
         seal: "seal";
-        gallery: "gallery";
     }>>;
 }, z.core.$strip>;
 export type RelocatableMediaCountInput = z.infer<typeof RelocatableMediaCountInputSchema>;
@@ -802,12 +802,12 @@ export type RelocatableMediaCountInput = z.infer<typeof RelocatableMediaCountInp
  * with no operator-visible status.
  */
 export declare const StorageCleanupPhaseSchema: z.ZodEnum<{
-    done: "done";
-    failed: "failed";
     cancelled: "cancelled";
-    orphans: "orphans";
     "debug-media": "debug-media";
+    done: "done";
+    failed: "failed";
     "ghost-ledger": "ghost-ledger";
+    orphans: "orphans";
 }>;
 export type StorageCleanupPhase = z.infer<typeof StorageCleanupPhaseSchema>;
 export declare const StorageCleanupInputSchema: z.ZodObject<{
@@ -817,12 +817,12 @@ export type StorageCleanupInput = z.infer<typeof StorageCleanupInputSchema>;
 export declare const StorageCleanupJobSchema: z.ZodObject<{
     jobId: z.ZodString;
     phase: z.ZodEnum<{
-        done: "done";
-        failed: "failed";
         cancelled: "cancelled";
-        orphans: "orphans";
         "debug-media": "debug-media";
+        done: "done";
+        failed: "failed";
         "ghost-ledger": "ghost-ledger";
+        orphans: "orphans";
     }>;
     includeDebugMedia: z.ZodBoolean;
     orphansReclaimed: z.ZodNumber;

package/dist/interfaces/server-analysis.d.ts

@@ -29,9 +29,9 @@ export interface AnalysisDetection {
     zones?: string[];
     previousZones?: string[];
 }
-export declare const SUB_DETECTION_TYPES: readonly ["face", "plate"];
+export declare const SUB_DETECTION_TYPES: readonly ['face', 'plate'];
 export type SubDetectionType = (typeof SUB_DETECTION_TYPES)[number];
-export declare const RECOGNITION_TYPES: readonly ["face", "plate", "clip", "custom"];
+export declare const RECOGNITION_TYPES: readonly ['face', 'plate', 'clip', 'custom'];
 export type RecognitionType = (typeof RECOGNITION_TYPES)[number];
 export interface AnalysisContext {
     readonly deviceId: string;

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

@@ -45,8 +45,8 @@ import { z } from 'zod';
  * a declared, enforced, testable refusal.
  */
 export declare const StorageAccessSchema: z.ZodEnum<{
-    "local-path": "local-path";
     "cap-mediated": "cap-mediated";
+    "local-path": "local-path";
 }>;
 export type StorageAccess = z.infer<typeof StorageAccessSchema>;
 /**
@@ -60,18 +60,18 @@ export declare const StorageLocationDeclarationSchema: z.ZodObject<{
     displayName: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     cardinality: z.ZodEnum<{
-        single: "single";
         multi: "multi";
+        single: "single";
     }>;
     access: z.ZodOptional<z.ZodEnum<{
-        "local-path": "local-path";
         "cap-mediated": "cap-mediated";
+        "local-path": "local-path";
     }>>;
     defaultsTo: z.ZodOptional<z.ZodString>;
     defaultRoot: z.ZodOptional<z.ZodEnum<{
+        backup: "backup";
         data: "data";
         media: "media";
-        backup: "backup";
     }>>;
 }, z.core.$strip>;
 /** Inferred TypeScript type for `StorageLocationDeclarationSchema`. */

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

@@ -27,16 +27,16 @@ import { z } from 'zod';
  * anything outside this module reads `config['readOnly']` or compares `enabled`
  * directly. A rule nothing checks has already been broken somewhere.
  */
-export declare const STORAGE_LOCATION_MODES: readonly ["active", "readonly", "drain", "disabled"];
+export declare const STORAGE_LOCATION_MODES: readonly ['active', 'readonly', 'drain', 'disabled'];
 /**
  * The one typed state of a storage location. Authoritative Zod schema — the TS
  * alias below is `z.infer<>` of it, never a second spelling.
  */
 export declare const StorageLocationModeSchema: z.ZodEnum<{
-    readonly: "readonly";
-    disabled: "disabled";
     active: "active";
+    disabled: "disabled";
     drain: "drain";
+    readonly: "readonly";
 }>;
 export type StorageLocationMode = z.infer<typeof StorageLocationModeSchema>;
 /**
@@ -52,8 +52,8 @@ export type StorageLocationMode = z.infer<typeof StorageLocationModeSchema>;
  *              writing to.
  */
 export declare const StorageEvictionPolicySchema: z.ZodEnum<{
-    never: "never";
     drain: "drain";
+    never: "never";
     normal: "normal";
 }>;
 export type StorageEvictionPolicy = z.infer<typeof StorageEvictionPolicySchema>;

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

@@ -52,10 +52,10 @@ export declare const StorageLocationSchema: z.ZodObject<{
     isSystem: z.ZodDefault<z.ZodBoolean>;
     enabled: z.ZodOptional<z.ZodBoolean>;
     mode: z.ZodOptional<z.ZodEnum<{
-        readonly: "readonly";
-        disabled: "disabled";
         active: "active";
+        disabled: "disabled";
         drain: "drain";
+        readonly: "readonly";
     }>>;
     capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         totalBytes: z.ZodNumber;

package/dist/interfaces/track-relations.d.ts

@@ -14,13 +14,13 @@ export declare const MAX_TRACK_RELATIONS = 20000;
 export declare const MAX_TRACK_PURITIES = 5000;
 export declare const TRACK_RELATIONS_DEFAULT_LIMIT = 500;
 export declare const TrackRelationKindSchema: z.ZodEnum<{
-    "same-subject": "same-subject";
     "different-subjects": "different-subjects";
+    "same-subject": "same-subject";
 }>;
 export type TrackRelationKind = z.infer<typeof TrackRelationKindSchema>;
 export declare const TrackSideSchema: z.ZodEnum<{
-    before: "before";
     after: "after";
+    before: "before";
 }>;
 export type TrackSide = z.infer<typeof TrackSideSchema>;
 export declare const TrackPurityValueSchema: z.ZodEnum<{
@@ -34,16 +34,16 @@ export declare const TrackRelationSchema: z.ZodObject<{
     leftTrackId: z.ZodString;
     rightTrackId: z.ZodString;
     leftSide: z.ZodNullable<z.ZodEnum<{
-        before: "before";
         after: "after";
+        before: "before";
     }>>;
     rightSide: z.ZodNullable<z.ZodEnum<{
-        before: "before";
         after: "after";
+        before: "before";
     }>>;
     relation: z.ZodEnum<{
-        "same-subject": "same-subject";
         "different-subjects": "different-subjects";
+        "same-subject": "same-subject";
     }>;
     presence: z.ZodNullable<z.ZodLiteral<"continuous">>;
     leftStartedAt: z.ZodNullable<z.ZodNumber>;
@@ -73,17 +73,17 @@ export declare const SetTrackRelationInputSchema: z.ZodObject<{
     trackId: z.ZodString;
     otherTrackId: z.ZodString;
     relation: z.ZodEnum<{
-        "same-subject": "same-subject";
         "different-subjects": "different-subjects";
+        "same-subject": "same-subject";
     }>;
     presence: z.ZodOptional<z.ZodLiteral<"continuous">>;
     trackSide: z.ZodOptional<z.ZodEnum<{
-        before: "before";
         after: "after";
+        before: "before";
     }>>;
     otherSide: z.ZodOptional<z.ZodEnum<{
-        before: "before";
         after: "after";
+        before: "before";
     }>>;
 }, z.core.$strip>;
 export type SetTrackRelationInput = z.infer<typeof SetTrackRelationInputSchema>;
@@ -141,16 +141,16 @@ export declare const ListTrackRelationsResultSchema: z.ZodObject<{
         leftTrackId: z.ZodString;
         rightTrackId: z.ZodString;
         leftSide: z.ZodNullable<z.ZodEnum<{
-            before: "before";
             after: "after";
+            before: "before";
         }>>;
         rightSide: z.ZodNullable<z.ZodEnum<{
-            before: "before";
             after: "after";
+            before: "before";
         }>>;
         relation: z.ZodEnum<{
-            "same-subject": "same-subject";
             "different-subjects": "different-subjects";
+            "same-subject": "same-subject";
         }>;
         presence: z.ZodNullable<z.ZodLiteral<"continuous">>;
         leftStartedAt: z.ZodNullable<z.ZodNumber>;
@@ -177,11 +177,11 @@ export declare const ListTrackRelationsResultSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type ListTrackRelationsResult = z.infer<typeof ListTrackRelationsResultSchema>;
 export declare const TrackRelationRefusalSchema: z.ZodEnum<{
-    "unknown-track": "unknown-track";
+    contradiction: "contradiction";
     "cross-device": "cross-device";
     "self-relation": "self-relation";
-    contradiction: "contradiction";
-    "switch-outside-track": "switch-outside-track";
     "switch-needs-mixed": "switch-needs-mixed";
+    "switch-outside-track": "switch-outside-track";
+    "unknown-track": "unknown-track";
 }>;
 export type TrackRelationRefusal = z.infer<typeof TrackRelationRefusalSchema>;