@camstack/types 1.2.336 → 1.2.337

package/dist/capabilities/lock-control.cap.d.ts

@@ -22,29 +22,29 @@ import { DeviceType } from '../device/device-type.js';
  * `supported_features`.
  */
 export declare const LockStateSchema: z.ZodEnum<{
+    jammed: "jammed";
     locked: "locked";
-    unlocked: "unlocked";
     locking: "locking";
+    unlocked: "unlocked";
     unlocking: "unlocking";
-    jammed: "jammed";
 }>;
 export type LockState = z.infer<typeof LockStateSchema>;
 export declare const LockControlStatusSchema: z.ZodObject<{
     state: z.ZodEnum<{
+        jammed: "jammed";
         locked: "locked";
-        unlocked: "unlocked";
         locking: "locking";
+        unlocked: "unlocked";
         unlocking: "unlocking";
-        jammed: "jammed";
     }>;
     lastChangedAt: z.ZodNumber;
 }, z.core.$strip>;
 export type LockControlStatus = z.infer<typeof LockControlStatusSchema>;
 export declare const lockControlCapability: {
-    readonly name: "lock-control";
-    readonly scope: "device";
+    readonly name: 'lock-control';
+    readonly scope: 'device';
     readonly deviceNative: true;
-    readonly mode: "singleton";
+    readonly mode: 'singleton';
     readonly deviceTypes: readonly [DeviceType.Lock];
     readonly methods: {
         readonly lock: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
@@ -62,15 +62,15 @@ export declare const lockControlCapability: {
     readonly status: {
         readonly schema: z.ZodObject<{
             state: z.ZodEnum<{
+                jammed: "jammed";
                 locked: "locked";
-                unlocked: "unlocked";
                 locking: "locking";
+                unlocked: "unlocked";
                 unlocking: "unlocking";
-                jammed: "jammed";
             }>;
             lastChangedAt: z.ZodNumber;
         }, z.core.$strip>;
-        readonly kind: "push";
+        readonly kind: 'push';
     };
     /**
      * Runtime-state slice — mirrored by the kernel. UI lock buttons
@@ -79,11 +79,11 @@ export declare const lockControlCapability: {
      */
     readonly runtimeState: z.ZodObject<{
         state: z.ZodEnum<{
+            jammed: "jammed";
             locked: "locked";
-            unlocked: "unlocked";
             locking: "locking";
+            unlocked: "unlocked";
             unlocking: "unlocking";
-            jammed: "jammed";
         }>;
         lastChangedAt: z.ZodNumber;
     }, z.core.$strip>;
@@ -93,7 +93,7 @@ export declare const lockControlCapability: {
      * See `RuntimeStateDurability`. Enforced by
      * `scripts/check-runtime-state-durability.ts`.
      */
-    readonly durability: "restored";
+    readonly durability: 'restored';
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastChangedAt"];

package/dist/capabilities/log-channels.cap.d.ts

@@ -47,9 +47,9 @@ declare const LogChannelApplyResultSchema: z.ZodObject<{
     unknown: z.ZodReadonly<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export declare const logChannelsCapability: {
-    readonly name: "log-channels";
-    readonly scope: "system";
-    readonly mode: "collection";
+    readonly name: 'log-channels';
+    readonly scope: 'system';
+    readonly mode: 'collection';
     readonly internal: true;
     readonly methods: {
         /** The channels this addon declares. Inert: no value, no state. */
@@ -57,8 +57,8 @@ export declare const logChannelsCapability: {
             name: z.ZodString;
             description: z.ZodString;
             defaultLevel: z.ZodEnum<{
-                info: "info";
                 error: "error";
+                info: "info";
                 warn: "warn";
             }>;
             perDevice: z.ZodBoolean;
@@ -85,7 +85,7 @@ export declare const logChannelsCapability: {
     };
     /** In-process only — enumerated through `addons.listCapabilityProviders`. */
     readonly mount: {
-        readonly kind: "skip";
+        readonly kind: 'skip';
     };
 };
 export type ILogChannelsProvider = InferProvider<typeof logChannelsCapability>;

package/dist/capabilities/log-destination.cap.d.ts

@@ -1,17 +1,17 @@
 import { z } from 'zod';
 import { type InferProvider } from './capability-definition.js';
 declare const LogLevelSchema: z.ZodEnum<{
-    info: "info";
-    error: "error";
     debug: "debug";
+    error: "error";
+    info: "info";
     warn: "warn";
 }>;
 declare const LogEntrySchema: z.ZodObject<{
     timestamp: z.ZodDate;
     level: z.ZodEnum<{
-        info: "info";
-        error: "error";
         debug: "debug";
+        error: "error";
+        info: "info";
         warn: "warn";
     }>;
     scope: z.ZodArray<z.ZodString>;
@@ -20,17 +20,17 @@ declare const LogEntrySchema: z.ZodObject<{
     tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;
 export declare const logDestinationCapability: {
-    readonly name: "log-destination";
-    readonly scope: "system";
-    readonly mode: "collection";
+    readonly name: 'log-destination';
+    readonly scope: 'system';
+    readonly mode: 'collection';
     readonly internal: true;
     readonly methods: {
         readonly write: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             timestamp: z.ZodDate;
             level: z.ZodEnum<{
-                info: "info";
-                error: "error";
                 debug: "debug";
+                error: "error";
+                info: "info";
                 warn: "warn";
             }>;
             scope: z.ZodArray<z.ZodString>;
@@ -41,9 +41,9 @@ export declare const logDestinationCapability: {
         readonly query: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
             level: z.ZodOptional<z.ZodEnum<{
-                info: "info";
-                error: "error";
                 debug: "debug";
+                error: "error";
+                info: "info";
                 warn: "warn";
             }>>;
             since: z.ZodOptional<z.ZodDate>;
@@ -53,9 +53,9 @@ export declare const logDestinationCapability: {
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             timestamp: z.ZodDate;
             level: z.ZodEnum<{
-                info: "info";
-                error: "error";
                 debug: "debug";
+                error: "error";
+                info: "info";
                 warn: "warn";
             }>;
             scope: z.ZodArray<z.ZodString>;
@@ -66,7 +66,7 @@ export declare const logDestinationCapability: {
     };
     /** BIG PLAN 2: declarative mount hint — read by `@camstack/system` `buildCapRouters`. */
     readonly mount: {
-        readonly kind: "skip";
+        readonly kind: 'skip';
     };
 };
 export type ILogDestinationProvider = InferProvider<typeof logDestinationCapability>;

package/dist/capabilities/login-method.cap.d.ts

@@ -138,9 +138,9 @@ export declare const LoginMethodContributionSchema: z.ZodDiscriminatedUnion<[z.Z
     origin: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>], "kind">;
 export declare const loginMethodCapability: {
-    readonly name: "login-method";
-    readonly scope: "system";
-    readonly mode: "collection";
+    readonly name: 'login-method';
+    readonly scope: 'system';
+    readonly mode: 'collection';
     readonly internal: true;
     readonly methods: {
         readonly getLoginMethods: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -182,7 +182,7 @@ export declare const loginMethodCapability: {
     };
     /** BIG PLAN 2: declarative mount hint — read by `@camstack/system` `buildCapRouters`. */
     readonly mount: {
-        readonly kind: "skip";
+        readonly kind: 'skip';
     };
 };
 export type ILoginMethodProvider = InferProvider<typeof loginMethodCapability>;

package/dist/capabilities/mask-shape.d.ts

@@ -72,10 +72,10 @@ export declare const MaskShapeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strip>], "kind">;
 /** Every shape-kind discriminant, for `supportedShapes` advertisement. */
 export declare const MaskShapeKindSchema: z.ZodEnum<{
-    rect: "rect";
-    polygon: "polygon";
     grid: "grid";
     line: "line";
+    polygon: "polygon";
+    rect: "rect";
 }>;
 /** Polygon vertex bounds when a cap supports 'polygon' (e.g. Hikvision {min:4,max:4}). */
 export declare const MaskPolygonVerticesSchema: z.ZodObject<{

package/dist/capabilities/media-player.cap.d.ts

@@ -14,12 +14,12 @@ import { DeviceType } from '../device/device-type.js';
  * fetch — same pattern as `PanTiltZoom` for cameras.
  */
 export declare const MediaPlayerStateSchema: z.ZodEnum<{
+    buffering: "buffering";
     idle: "idle";
-    paused: "paused";
     off: "off";
     on: "on";
+    paused: "paused";
     playing: "playing";
-    buffering: "buffering";
     standby: "standby";
 }>;
 export type MediaPlayerState = z.infer<typeof MediaPlayerStateSchema>;
@@ -39,12 +39,12 @@ declare const MediaInfoSchema: z.ZodObject<{
 export type MediaInfo = z.infer<typeof MediaInfoSchema>;
 export declare const MediaPlayerStatusSchema: z.ZodObject<{
     state: z.ZodEnum<{
+        buffering: "buffering";
         idle: "idle";
-        paused: "paused";
         off: "off";
         on: "on";
+        paused: "paused";
         playing: "playing";
-        buffering: "buffering";
         standby: "standby";
     }>;
     volumeLevel: z.ZodNullable<z.ZodNumber>;
@@ -70,10 +70,10 @@ export declare const MediaPlayerStatusSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type MediaPlayerStatus = z.infer<typeof MediaPlayerStatusSchema>;
 export declare const mediaPlayerCapability: {
-    readonly name: "media-player";
-    readonly scope: "device";
+    readonly name: 'media-player';
+    readonly scope: 'device';
     readonly deviceNative: true;
-    readonly mode: "singleton";
+    readonly mode: 'singleton';
     readonly deviceTypes: readonly [DeviceType.MediaPlayer];
     readonly methods: {
         readonly play: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
@@ -128,12 +128,12 @@ export declare const mediaPlayerCapability: {
     readonly status: {
         readonly schema: z.ZodObject<{
             state: z.ZodEnum<{
+                buffering: "buffering";
                 idle: "idle";
-                paused: "paused";
                 off: "off";
                 on: "on";
+                paused: "paused";
                 playing: "playing";
-                buffering: "buffering";
                 standby: "standby";
             }>;
             volumeLevel: z.ZodNullable<z.ZodNumber>;
@@ -157,7 +157,7 @@ export declare const mediaPlayerCapability: {
             }>>;
             lastChangedAt: z.ZodNumber;
         }, z.core.$strip>;
-        readonly kind: "push";
+        readonly kind: 'push';
     };
     /**
      * Runtime-state slice — mirrored by the kernel. UI players read the
@@ -166,12 +166,12 @@ export declare const mediaPlayerCapability: {
      */
     readonly runtimeState: z.ZodObject<{
         state: z.ZodEnum<{
+            buffering: "buffering";
             idle: "idle";
-            paused: "paused";
             off: "off";
             on: "on";
+            paused: "paused";
             playing: "playing";
-            buffering: "buffering";
             standby: "standby";
         }>;
         volumeLevel: z.ZodNullable<z.ZodNumber>;
@@ -201,7 +201,7 @@ export declare const mediaPlayerCapability: {
      * See `RuntimeStateDurability`. Enforced by
      * `scripts/check-runtime-state-durability.ts`.
      */
-    readonly durability: "session";
+    readonly durability: 'session';
 };
 export type IMediaPlayerProvider = InferProvider<typeof mediaPlayerCapability>;
 export {};

package/dist/capabilities/mesh-network.cap.d.ts

@@ -27,8 +27,8 @@ declare const MeshEndpointSchema: z.ZodObject<{
     id: z.ZodString;
     label: z.ZodString;
     scope: z.ZodEnum<{
-        public: "public";
         mesh: "mesh";
+        public: "public";
     }>;
     url: z.ZodString;
     hostname: z.ZodString;
@@ -49,8 +49,8 @@ export declare const MeshPeerSchema: z.ZodObject<{
     lastSeenMs: z.ZodNumber;
     isSelf: z.ZodBoolean;
     connection: z.ZodEnum<{
-        idle: "idle";
         direct: "direct";
+        idle: "idle";
         relay: "relay";
     }>;
     relay: z.ZodNullable<z.ZodString>;
@@ -73,8 +73,8 @@ export declare const MeshStatusSchema: z.ZodObject<{
         id: z.ZodString;
         label: z.ZodString;
         scope: z.ZodEnum<{
-            public: "public";
             mesh: "mesh";
+            public: "public";
         }>;
         url: z.ZodString;
         hostname: z.ZodString;
@@ -100,10 +100,10 @@ export type MeshStatus = z.infer<typeof MeshStatusSchema>;
  * register their own entries.
  */
 export declare const meshNetworkCapability: {
-    readonly name: "mesh-network";
-    readonly scope: "system";
-    readonly mode: "collection";
-    readonly providerKind: "mesh";
+    readonly name: 'mesh-network';
+    readonly scope: 'system';
+    readonly mode: 'collection';
+    readonly providerKind: 'mesh';
     readonly methods: {
         /** Return the current join state + endpoints + peer count. Cheap
          *  poll-target — admin UI hits this every few seconds. */
@@ -116,8 +116,8 @@ export declare const meshNetworkCapability: {
                 id: z.ZodString;
                 label: z.ZodString;
                 scope: z.ZodEnum<{
-                    public: "public";
                     mesh: "mesh";
+                    public: "public";
                 }>;
                 url: z.ZodString;
                 hostname: z.ZodString;
@@ -194,8 +194,8 @@ export declare const meshNetworkCapability: {
                 lastSeenMs: z.ZodNumber;
                 isSelf: z.ZodBoolean;
                 connection: z.ZodEnum<{
-                    idle: "idle";
                     direct: "direct";
+                    idle: "idle";
                     relay: "relay";
                 }>;
                 relay: z.ZodNullable<z.ZodString>;

package/dist/capabilities/metrics-provider.cap.d.ts

@@ -169,10 +169,10 @@ declare const AddonInstanceSchema: z.ZodObject<{
     }>;
     pid: z.ZodNumber;
     state: z.ZodEnum<{
+        crashed: "crashed";
         running: "running";
-        stopped: "stopped";
         starting: "starting";
-        crashed: "crashed";
+        stopped: "stopped";
         stopping: "stopping";
     }>;
     uptimeSec: z.ZodNumber;
@@ -182,9 +182,9 @@ declare const NodeProcessSchema: z.ZodObject<{
     ppid: z.ZodNumber;
     pgid: z.ZodNumber;
     classification: z.ZodEnum<{
-        system: "system";
-        root: "root";
         managed: "managed";
+        root: "root";
+        system: "system";
     }>;
     addonId: z.ZodNullable<z.ZodString>;
     nodeId: z.ZodNullable<z.ZodString>;
@@ -198,8 +198,8 @@ declare const NodeProcessSchema: z.ZodObject<{
 }, z.core.$strip>;
 declare const ContainerMemorySnapshotSchema: z.ZodObject<{
     source: z.ZodEnum<{
-        "cgroup-v2": "cgroup-v2";
         "cgroup-v1": "cgroup-v1";
+        "cgroup-v2": "cgroup-v2";
     }>;
     currentBytes: z.ZodNumber;
     limitBytes: z.ZodNullable<z.ZodNumber>;
@@ -223,8 +223,8 @@ declare const ContainerMemorySnapshotSchema: z.ZodObject<{
  */
 declare const ContainerMemoryPointSchema: z.ZodObject<{
     source: z.ZodEnum<{
-        "cgroup-v2": "cgroup-v2";
         "cgroup-v1": "cgroup-v1";
+        "cgroup-v2": "cgroup-v2";
     }>;
     currentBytes: z.ZodNumber;
     limitBytes: z.ZodNullable<z.ZodNumber>;
@@ -312,8 +312,8 @@ declare const NodeLoadSeriesSchema: z.ZodObject<{
     }, z.core.$strip>>>;
     containerMemory: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         source: z.ZodEnum<{
-            "cgroup-v2": "cgroup-v2";
             "cgroup-v1": "cgroup-v1";
+            "cgroup-v2": "cgroup-v2";
         }>;
         currentBytes: z.ZodNumber;
         limitBytes: z.ZodNullable<z.ZodNumber>;
@@ -346,9 +346,9 @@ declare const SystemMetricsSchema: z.ZodObject<{
     gpuMemoryPercent: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export declare const metricsProviderCapability: {
-    readonly name: "metrics-provider";
-    readonly scope: "system";
-    readonly mode: "singleton";
+    readonly name: 'metrics-provider';
+    readonly scope: 'system';
+    readonly mode: 'singleton';
     readonly methods: {
         /** Fresh, full system snapshot (triggers OS-level collection). */
         readonly collectSnapshot: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
@@ -584,10 +584,10 @@ export declare const metricsProviderCapability: {
             }>;
             pid: z.ZodNumber;
             state: z.ZodEnum<{
+                crashed: "crashed";
                 running: "running";
-                stopped: "stopped";
                 starting: "starting";
-                crashed: "crashed";
+                stopped: "stopped";
                 stopping: "stopping";
             }>;
             uptimeSec: z.ZodNumber;
@@ -626,9 +626,9 @@ export declare const metricsProviderCapability: {
             ppid: z.ZodNumber;
             pgid: z.ZodNumber;
             classification: z.ZodEnum<{
-                system: "system";
-                root: "root";
                 managed: "managed";
+                root: "root";
+                system: "system";
             }>;
             addonId: z.ZodNullable<z.ZodString>;
             nodeId: z.ZodNullable<z.ZodString>;
@@ -687,8 +687,8 @@ export declare const metricsProviderCapability: {
             }, z.core.$strip>>>;
             containerMemory: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                 source: z.ZodEnum<{
-                    "cgroup-v2": "cgroup-v2";
                     "cgroup-v1": "cgroup-v1";
+                    "cgroup-v2": "cgroup-v2";
                 }>;
                 currentBytes: z.ZodNumber;
                 limitBytes: z.ZodNullable<z.ZodNumber>;

package/dist/capabilities/model-convert.cap.d.ts

@@ -21,10 +21,10 @@ export declare const ModelConvertInputSchema: z.ZodObject<{
             nhwc: "nhwc";
         }>>;
         inputNormalization: z.ZodOptional<z.ZodEnum<{
-            none: "none";
-            "zero-one": "zero-one";
             imagenet: "imagenet";
+            none: "none";
             scrfd: "scrfd";
+            "zero-one": "zero-one";
         }>>;
         preprocessMode: z.ZodOptional<z.ZodEnum<{
             letterbox: "letterbox";
@@ -32,19 +32,19 @@ export declare const ModelConvertInputSchema: z.ZodObject<{
         }>>;
         outputFormat: z.ZodEnum<{
             classification: "classification";
-            segmentation: "segmentation";
-            yolo: "yolo";
-            ssd: "ssd";
             embedding: "embedding";
             ocr: "ocr";
+            segmentation: "segmentation";
+            ssd: "ssd";
+            yolo: "yolo";
         }>;
         faceAlignment: z.ZodOptional<z.ZodBoolean>;
         classMap: z.ZodOptional<z.ZodObject<{
             mapping: z.ZodRecord<z.ZodString, z.ZodEnum<{
-                person: "person";
-                vehicle: "vehicle";
                 animal: "animal";
                 package: "package";
+                person: "person";
+                vehicle: "vehicle";
             }>>;
             preserveOriginal: z.ZodBoolean;
         }, z.core.$strip>>;
@@ -63,9 +63,9 @@ export declare const ModelConvertInputSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type ModelConvertInput = z.infer<typeof ModelConvertInputSchema>;
 export declare const modelConvertCapability: {
-    readonly name: "model-convert";
-    readonly scope: "system";
-    readonly mode: "singleton";
+    readonly name: 'model-convert';
+    readonly scope: 'system';
+    readonly mode: 'singleton';
     readonly internal: true;
     readonly methods: {
         readonly convert: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
@@ -89,10 +89,10 @@ export declare const modelConvertCapability: {
                     nhwc: "nhwc";
                 }>>;
                 inputNormalization: z.ZodOptional<z.ZodEnum<{
-                    none: "none";
-                    "zero-one": "zero-one";
                     imagenet: "imagenet";
+                    none: "none";
                     scrfd: "scrfd";
+                    "zero-one": "zero-one";
                 }>>;
                 preprocessMode: z.ZodOptional<z.ZodEnum<{
                     letterbox: "letterbox";
@@ -100,19 +100,19 @@ export declare const modelConvertCapability: {
                 }>>;
                 outputFormat: z.ZodEnum<{
                     classification: "classification";
-                    segmentation: "segmentation";
-                    yolo: "yolo";
-                    ssd: "ssd";
                     embedding: "embedding";
                     ocr: "ocr";
+                    segmentation: "segmentation";
+                    ssd: "ssd";
+                    yolo: "yolo";
                 }>;
                 faceAlignment: z.ZodOptional<z.ZodBoolean>;
                 classMap: z.ZodOptional<z.ZodObject<{
                     mapping: z.ZodRecord<z.ZodString, z.ZodEnum<{
-                        person: "person";
-                        vehicle: "vehicle";
                         animal: "animal";
                         package: "package";
+                        person: "person";
+                        vehicle: "vehicle";
                     }>>;
                     preserveOriginal: z.ZodBoolean;
                 }, z.core.$strip>>;
@@ -212,10 +212,10 @@ export declare const modelConvertCapability: {
                     nhwc: "nhwc";
                 }>>;
                 inputNormalization: z.ZodOptional<z.ZodEnum<{
-                    none: "none";
-                    "zero-one": "zero-one";
                     imagenet: "imagenet";
+                    none: "none";
                     scrfd: "scrfd";
+                    "zero-one": "zero-one";
                 }>>;
                 outputProbabilities: z.ZodOptional<z.ZodBoolean>;
                 preprocessMode: z.ZodOptional<z.ZodEnum<{
@@ -226,8 +226,8 @@ export declare const modelConvertCapability: {
                 defaultConfidence: z.ZodOptional<z.ZodNumber>;
                 defaultClassFloors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
                 gpuInferencePrecision: z.ZodOptional<z.ZodEnum<{
-                    f32: "f32";
                     f16: "f16";
+                    f32: "f32";
                 }>>;
                 suppliedLabelFloors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
                 faceAlignment: z.ZodOptional<z.ZodBoolean>;
@@ -257,9 +257,9 @@ export declare const modelConvertCapability: {
                     attribution: z.ZodOptional<z.ZodString>;
                     modifications: z.ZodOptional<z.ZodString>;
                     hosting: z.ZodOptional<z.ZodEnum<{
+                        "built-in": "built-in";
                         "camstack-hf": "camstack-hf";
                         "third-party": "third-party";
-                        "built-in": "built-in";
                     }>>;
                     nonCommercial: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strip>>>;
@@ -277,17 +277,17 @@ export declare const modelConvertCapability: {
                     resolution: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strip>>;
                 provider: z.ZodOptional<z.ZodEnum<{
-                    custom: "custom";
                     camstack: "camstack";
+                    custom: "custom";
                     frigate: "frigate";
                     scrypted: "scrypted";
                 }>>;
                 classMap: z.ZodOptional<z.ZodObject<{
                     mapping: z.ZodRecord<z.ZodString, z.ZodEnum<{
-                        person: "person";
-                        vehicle: "vehicle";
                         animal: "animal";
                         package: "package";
+                        person: "person";
+                        vehicle: "vehicle";
                     }>>;
                     preserveOriginal: z.ZodBoolean;
                 }, z.core.$strip>>;
@@ -295,16 +295,16 @@ export declare const modelConvertCapability: {
                     kind: z.ZodLiteral<"label">;
                     stepId: z.ZodEnum<{
                         "animal-classifier": "animal-classifier";
-                        "vehicle-classifier": "vehicle-classifier";
                         "package-detection": "package-detection";
+                        "vehicle-classifier": "vehicle-classifier";
                     }>;
                     labelToEffect: z.ZodRecord<z.ZodString, z.ZodString>;
                     uncovered: z.ZodReadonly<z.ZodArray<z.ZodString>>;
                 }, z.core.$strip>, z.ZodObject<{
                     kind: z.ZodLiteral<"crop">;
                     stepId: z.ZodEnum<{
-                        "plate-detection": "plate-detection";
                         "face-detection": "face-detection";
+                        "plate-detection": "plate-detection";
                     }>;
                     rootLabels: z.ZodReadonly<z.ZodArray<z.ZodString>>;
                     parentMacro: z.ZodEnum<{
@@ -334,12 +334,12 @@ export declare const modelConvertCapability: {
             }, z.core.$strip>;
             artifacts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                 format: z.ZodEnum<{
-                    onnx: "onnx";
                     coreml: "coreml";
+                    gguf: "gguf";
+                    onnx: "onnx";
                     openvino: "openvino";
-                    tflite: "tflite";
                     pt: "pt";
-                    gguf: "gguf";
+                    tflite: "tflite";
                 }>;
                 precision: z.ZodOptional<z.ZodEnum<{
                     fp16: "fp16";