@camstack/types 1.2.336 → 1.2.338

package/dist/capabilities/platform-probe.cap.d.ts

@@ -1,32 +1,32 @@
 import { z } from 'zod';
 import { type InferProvider } from './capability-definition.js';
 declare const HardwareEncoderIdSchema: z.ZodEnum<{
-    h264_videotoolbox: "h264_videotoolbox";
-    hevc_videotoolbox: "hevc_videotoolbox";
-    h264_vaapi: "h264_vaapi";
-    hevc_vaapi: "hevc_vaapi";
+    h264_amf: "h264_amf";
     h264_nvenc: "h264_nvenc";
-    hevc_nvenc: "hevc_nvenc";
     h264_qsv: "h264_qsv";
-    hevc_qsv: "hevc_qsv";
-    h264_amf: "h264_amf";
+    h264_vaapi: "h264_vaapi";
+    h264_videotoolbox: "h264_videotoolbox";
     hevc_amf: "hevc_amf";
+    hevc_nvenc: "hevc_nvenc";
+    hevc_qsv: "hevc_qsv";
+    hevc_vaapi: "hevc_vaapi";
+    hevc_videotoolbox: "hevc_videotoolbox";
     libx264: "libx264";
     libx265: "libx265";
 }>;
 export type HardwareEncoderId = z.infer<typeof HardwareEncoderIdSchema>;
 declare const HardwareEncoderProbeSchema: z.ZodObject<{
     encoder: z.ZodEnum<{
-        h264_videotoolbox: "h264_videotoolbox";
-        hevc_videotoolbox: "hevc_videotoolbox";
-        h264_vaapi: "h264_vaapi";
-        hevc_vaapi: "hevc_vaapi";
+        h264_amf: "h264_amf";
         h264_nvenc: "h264_nvenc";
-        hevc_nvenc: "hevc_nvenc";
         h264_qsv: "h264_qsv";
-        hevc_qsv: "hevc_qsv";
-        h264_amf: "h264_amf";
+        h264_vaapi: "h264_vaapi";
+        h264_videotoolbox: "h264_videotoolbox";
         hevc_amf: "hevc_amf";
+        hevc_nvenc: "hevc_nvenc";
+        hevc_qsv: "hevc_qsv";
+        hevc_vaapi: "hevc_vaapi";
+        hevc_videotoolbox: "hevc_videotoolbox";
         libx264: "libx264";
         libx265: "libx265";
     }>;
@@ -35,12 +35,12 @@ declare const HardwareEncoderProbeSchema: z.ZodObject<{
         H265: "H265";
     }>;
     family: z.ZodEnum<{
-        videotoolbox: "videotoolbox";
-        vaapi: "vaapi";
-        qsv: "qsv";
         amf: "amf";
         nvenc: "nvenc";
+        qsv: "qsv";
         software: "software";
+        vaapi: "vaapi";
+        videotoolbox: "videotoolbox";
     }>;
     available: z.ZodBoolean;
     reason: z.ZodOptional<z.ZodString>;
@@ -49,16 +49,16 @@ export type HardwareEncoderProbe = z.infer<typeof HardwareEncoderProbeSchema>;
 declare const HardwareEncodersSchema: z.ZodObject<{
     encoders: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         encoder: z.ZodEnum<{
-            h264_videotoolbox: "h264_videotoolbox";
-            hevc_videotoolbox: "hevc_videotoolbox";
-            h264_vaapi: "h264_vaapi";
-            hevc_vaapi: "hevc_vaapi";
+            h264_amf: "h264_amf";
             h264_nvenc: "h264_nvenc";
-            hevc_nvenc: "hevc_nvenc";
             h264_qsv: "h264_qsv";
-            hevc_qsv: "hevc_qsv";
-            h264_amf: "h264_amf";
+            h264_vaapi: "h264_vaapi";
+            h264_videotoolbox: "h264_videotoolbox";
             hevc_amf: "hevc_amf";
+            hevc_nvenc: "hevc_nvenc";
+            hevc_qsv: "hevc_qsv";
+            hevc_vaapi: "hevc_vaapi";
+            hevc_videotoolbox: "hevc_videotoolbox";
             libx264: "libx264";
             libx265: "libx265";
         }>;
@@ -67,41 +67,41 @@ declare const HardwareEncodersSchema: z.ZodObject<{
             H265: "H265";
         }>;
         family: z.ZodEnum<{
-            videotoolbox: "videotoolbox";
-            vaapi: "vaapi";
-            qsv: "qsv";
             amf: "amf";
             nvenc: "nvenc";
+            qsv: "qsv";
             software: "software";
+            vaapi: "vaapi";
+            videotoolbox: "videotoolbox";
         }>;
         available: z.ZodBoolean;
         reason: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     defaultH264: z.ZodEnum<{
-        h264_videotoolbox: "h264_videotoolbox";
-        hevc_videotoolbox: "hevc_videotoolbox";
-        h264_vaapi: "h264_vaapi";
-        hevc_vaapi: "hevc_vaapi";
+        h264_amf: "h264_amf";
         h264_nvenc: "h264_nvenc";
-        hevc_nvenc: "hevc_nvenc";
         h264_qsv: "h264_qsv";
-        hevc_qsv: "hevc_qsv";
-        h264_amf: "h264_amf";
+        h264_vaapi: "h264_vaapi";
+        h264_videotoolbox: "h264_videotoolbox";
         hevc_amf: "hevc_amf";
+        hevc_nvenc: "hevc_nvenc";
+        hevc_qsv: "hevc_qsv";
+        hevc_vaapi: "hevc_vaapi";
+        hevc_videotoolbox: "hevc_videotoolbox";
         libx264: "libx264";
         libx265: "libx265";
     }>;
     defaultH265: z.ZodEnum<{
-        h264_videotoolbox: "h264_videotoolbox";
-        hevc_videotoolbox: "hevc_videotoolbox";
-        h264_vaapi: "h264_vaapi";
-        hevc_vaapi: "hevc_vaapi";
+        h264_amf: "h264_amf";
         h264_nvenc: "h264_nvenc";
-        hevc_nvenc: "hevc_nvenc";
         h264_qsv: "h264_qsv";
-        hevc_qsv: "hevc_qsv";
-        h264_amf: "h264_amf";
+        h264_vaapi: "h264_vaapi";
+        h264_videotoolbox: "h264_videotoolbox";
         hevc_amf: "hevc_amf";
+        hevc_nvenc: "hevc_nvenc";
+        hevc_qsv: "hevc_qsv";
+        hevc_vaapi: "hevc_vaapi";
+        hevc_videotoolbox: "hevc_videotoolbox";
         libx264: "libx264";
         libx265: "libx265";
     }>;
@@ -122,9 +122,9 @@ declare const HardwareDecodeAccelsSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type HardwareDecodeAccels = z.infer<typeof HardwareDecodeAccelsSchema>;
 export declare const platformProbeCapability: {
-    readonly name: "platform-probe";
-    readonly scope: "system";
-    readonly mode: "singleton";
+    readonly name: 'platform-probe';
+    readonly scope: 'system';
+    readonly mode: 'singleton';
     readonly methods: {
         readonly getCapabilities: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
             hardware: z.ZodObject<{
@@ -143,19 +143,25 @@ export declare const platformProbeCapability: {
                 availableRAM_MB: z.ZodNumber;
                 gpu: z.ZodNullable<z.ZodObject<{
                     type: z.ZodEnum<{
-                        nvidia: "nvidia";
                         amd: "amd";
-                        intel: "intel";
                         apple: "apple";
+                        intel: "intel";
+                        nvidia: "nvidia";
                     }>;
                     name: z.ZodString;
                     memoryMB: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strip>>;
                 npu: z.ZodNullable<z.ZodObject<{
                     type: z.ZodEnum<{
+                        "amd-xdna": "amd-xdna";
                         "apple-ane": "apple-ane";
                         "intel-npu": "intel-npu";
                     }>;
+                    name: z.ZodOptional<z.ZodString>;
+                    generation: z.ZodOptional<z.ZodEnum<{
+                        xdna1: "xdna1";
+                        xdna2: "xdna2";
+                    }>>;
                 }, z.core.$strip>>;
                 coral: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                     type: z.ZodLiteral<"coral-edgetpu">;
@@ -166,8 +172,8 @@ export declare const platformProbeCapability: {
                 runtime: z.ZodLiteral<"python">;
                 backend: z.ZodString;
                 format: z.ZodEnum<{
-                    onnx: "onnx";
                     coreml: "coreml";
+                    onnx: "onnx";
                     openvino: "openvino";
                     tflite: "tflite";
                 }>;
@@ -179,8 +185,8 @@ export declare const platformProbeCapability: {
                 runtime: z.ZodLiteral<"python">;
                 backend: z.ZodString;
                 format: z.ZodEnum<{
-                    onnx: "onnx";
                     coreml: "coreml";
+                    onnx: "onnx";
                     openvino: "openvino";
                     tflite: "tflite";
                 }>;
@@ -194,12 +200,12 @@ export declare const platformProbeCapability: {
                 backend: z.ZodString;
                 device: z.ZodString;
                 format: z.ZodEnum<{
-                    onnx: "onnx";
                     coreml: "coreml";
+                    gguf: "gguf";
+                    onnx: "onnx";
                     openvino: "openvino";
-                    tflite: "tflite";
                     pt: "pt";
-                    gguf: "gguf";
+                    tflite: "tflite";
                 }>;
                 runtime: z.ZodLiteral<"python">;
                 score: z.ZodNumber;
@@ -222,19 +228,25 @@ export declare const platformProbeCapability: {
             availableRAM_MB: z.ZodNumber;
             gpu: z.ZodNullable<z.ZodObject<{
                 type: z.ZodEnum<{
-                    nvidia: "nvidia";
                     amd: "amd";
-                    intel: "intel";
                     apple: "apple";
+                    intel: "intel";
+                    nvidia: "nvidia";
                 }>;
                 name: z.ZodString;
                 memoryMB: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>;
             npu: z.ZodNullable<z.ZodObject<{
                 type: z.ZodEnum<{
+                    "amd-xdna": "amd-xdna";
                     "apple-ane": "apple-ane";
                     "intel-npu": "intel-npu";
                 }>;
+                name: z.ZodOptional<z.ZodString>;
+                generation: z.ZodOptional<z.ZodEnum<{
+                    xdna1: "xdna1";
+                    xdna2: "xdna2";
+                }>>;
             }, z.core.$strip>>;
             coral: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                 type: z.ZodLiteral<"coral-edgetpu">;
@@ -254,32 +266,32 @@ export declare const platformProbeCapability: {
             runtime: z.ZodLiteral<"python">;
             backend: z.ZodString;
             format: z.ZodEnum<{
-                onnx: "onnx";
                 coreml: "coreml";
+                gguf: "gguf";
+                onnx: "onnx";
                 openvino: "openvino";
-                tflite: "tflite";
                 pt: "pt";
-                gguf: "gguf";
+                tflite: "tflite";
             }>;
             reason: z.ZodString;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         readonly resolveHwAccel: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             prefer: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-                none: "none";
+                amf: "amf";
                 coreml: "coreml";
-                openvino: "openvino";
-                tensorrt: "tensorrt";
                 cuda: "cuda";
-                videotoolbox: "videotoolbox";
-                vaapi: "vaapi";
-                qsv: "qsv";
-                nvdec: "nvdec";
                 d3d11va: "d3d11va";
+                directml: "directml";
+                drm: "drm";
                 dxva2: "dxva2";
-                amf: "amf";
+                none: "none";
+                nvdec: "nvdec";
+                openvino: "openvino";
+                qsv: "qsv";
+                tensorrt: "tensorrt";
+                vaapi: "vaapi";
                 vdpau: "vdpau";
-                drm: "drm";
-                directml: "directml";
+                videotoolbox: "videotoolbox";
                 webgpu: "webgpu";
             }>>>;
         }, z.core.$strip>, z.ZodObject<{

package/dist/capabilities/power-meter.cap.d.ts

@@ -29,10 +29,10 @@ export declare const PowerMeterStatusSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type PowerMeterStatus = z.infer<typeof PowerMeterStatusSchema>;
 export declare const powerMeterCapability: {
-    readonly name: "power-meter";
-    readonly scope: "device";
+    readonly name: 'power-meter';
+    readonly scope: 'device';
     readonly deviceNative: true;
-    readonly mode: "singleton";
+    readonly mode: 'singleton';
     readonly deviceTypes: readonly [DeviceType.Sensor];
     readonly methods: {};
     readonly status: {
@@ -47,7 +47,7 @@ export declare const powerMeterCapability: {
             unit: z.ZodOptional<z.ZodString>;
             precision: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>;
-        readonly kind: "push";
+        readonly kind: 'push';
     };
     readonly runtimeState: z.ZodObject<{
         watts: z.ZodOptional<z.ZodNumber>;
@@ -66,7 +66,7 @@ export declare const powerMeterCapability: {
      * 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 ["lastFetchedAt"];

package/dist/capabilities/presence.cap.d.ts

@@ -36,10 +36,10 @@ export declare const PresenceStatusSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type PresenceStatus = z.infer<typeof PresenceStatusSchema>;
 export declare const presenceCapability: {
-    readonly name: "presence";
-    readonly scope: "device";
+    readonly name: 'presence';
+    readonly scope: 'device';
     readonly deviceNative: true;
-    readonly mode: "singleton";
+    readonly mode: 'singleton';
     readonly deviceTypes: readonly [DeviceType.Presence];
     readonly methods: {};
     readonly status: {
@@ -54,7 +54,7 @@ export declare const presenceCapability: {
             batteryPercent: z.ZodNullable<z.ZodNumber>;
             lastChangedAt: z.ZodNumber;
         }, z.core.$strip>;
-        readonly kind: "push";
+        readonly kind: 'push';
     };
     /**
      * Runtime-state slice — mirrored by the kernel. UI presence card
@@ -79,7 +79,7 @@ export declare const presenceCapability: {
      * 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/pressure-sensor.cap.d.ts

@@ -17,10 +17,10 @@ export declare const PressureSensorStatusSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type PressureSensorStatus = z.infer<typeof PressureSensorStatusSchema>;
 export declare const pressureSensorCapability: {
-    readonly name: "pressure-sensor";
-    readonly scope: "device";
+    readonly name: 'pressure-sensor';
+    readonly scope: 'device';
     readonly deviceNative: true;
-    readonly mode: "singleton";
+    readonly mode: 'singleton';
     readonly deviceTypes: readonly [DeviceType.Sensor];
     readonly methods: {};
     readonly status: {
@@ -30,7 +30,7 @@ export declare const pressureSensorCapability: {
             unit: z.ZodOptional<z.ZodString>;
             precision: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>;
-        readonly kind: "push";
+        readonly kind: 'push';
     };
     readonly runtimeState: z.ZodObject<{
         hpa: z.ZodNumber;
@@ -44,7 +44,7 @@ export declare const pressureSensorCapability: {
      * 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 ["lastFetchedAt"];

package/dist/capabilities/privacy-mask.cap.d.ts

@@ -86,10 +86,10 @@ export declare const PrivacyMaskStatusSchema: z.ZodObject<{
 export declare const PrivacyMaskOptionsSchema: z.ZodObject<{
     maxRegions: z.ZodNumber;
     supportedShapes: z.ZodArray<z.ZodEnum<{
-        rect: "rect";
-        polygon: "polygon";
         grid: "grid";
         line: "line";
+        polygon: "polygon";
+        rect: "rect";
     }>>;
     polygonVertices: z.ZodOptional<z.ZodObject<{
         min: z.ZodNumber;
@@ -124,17 +124,17 @@ export type PrivacyMaskStatus = z.infer<typeof PrivacyMaskStatusSchema>;
 export type PrivacyMaskOptions = z.infer<typeof PrivacyMaskOptionsSchema>;
 export type PrivacyMaskPatch = z.infer<typeof PrivacyMaskPatchSchema>;
 export declare const privacyMaskCapability: {
-    readonly name: "privacy-mask";
-    readonly scope: "device";
+    readonly name: 'privacy-mask';
+    readonly scope: 'device';
     readonly deviceNative: true;
-    readonly mode: "singleton";
+    readonly mode: 'singleton';
     readonly deviceTypes: readonly [DeviceType.Camera];
     readonly deviceConfig: {
         readonly ui: {
-            readonly kind: "widget";
-            readonly widgetId: "host/privacy-mask-grid";
-            readonly tab: "image";
-            readonly label: "Privacy Mask";
+            readonly kind: 'widget';
+            readonly widgetId: 'host/privacy-mask-grid';
+            readonly tab: 'image';
+            readonly label: 'Privacy Mask';
         };
     };
     readonly methods: {
@@ -143,10 +143,10 @@ export declare const privacyMaskCapability: {
         }, z.core.$strip>, z.ZodObject<{
             maxRegions: z.ZodNumber;
             supportedShapes: z.ZodArray<z.ZodEnum<{
-                rect: "rect";
-                polygon: "polygon";
                 grid: "grid";
                 line: "line";
+                polygon: "polygon";
+                rect: "rect";
             }>>;
             polygonVertices: z.ZodOptional<z.ZodObject<{
                 min: z.ZodNumber;
@@ -219,7 +219,7 @@ export declare const privacyMaskCapability: {
             audioEnabled: z.ZodNullable<z.ZodBoolean>;
             lastFetchedAt: z.ZodNumber;
         }, z.core.$strip>;
-        readonly kind: "poll";
+        readonly kind: 'poll';
     };
     readonly runtimeState: z.ZodObject<{
         enabled: z.ZodBoolean;
@@ -249,7 +249,7 @@ export declare const privacyMaskCapability: {
      * 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 ["lastFetchedAt"];

package/dist/capabilities/ptz-autotrack.cap.d.ts

@@ -62,10 +62,10 @@ export declare const PtzAutotrackRuntimeStateSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type PtzAutotrackRuntimeState = z.infer<typeof PtzAutotrackRuntimeStateSchema>;
 export declare const ptzAutotrackCapability: {
-    readonly name: "ptz-autotrack";
-    readonly scope: "device";
+    readonly name: 'ptz-autotrack';
+    readonly scope: 'device';
     readonly deviceNative: true;
-    readonly mode: "singleton";
+    readonly mode: 'singleton';
     /**
      * Two kinds of provider behind one name, the same shape `snapshot` uses:
      *
@@ -82,16 +82,16 @@ export declare const ptzAutotrackCapability: {
      * head, which is the whole reason this is not a second cap with a second
      * toggle (D62, D520).
      */
-    readonly kind: "wrapper";
+    readonly kind: 'wrapper';
     readonly defaultActive: false;
     readonly deviceTypes: readonly [DeviceType.Camera];
     readonly deviceConfig: {
         readonly ui: {
-            readonly kind: "widget";
-            readonly widgetId: "host/ptz-autotrack";
-            readonly tab: "ptz";
+            readonly kind: 'widget';
+            readonly widgetId: 'host/ptz-autotrack';
+            readonly tab: 'ptz';
             readonly topTab: true;
-            readonly label: "Auto-Tracking";
+            readonly label: 'Auto-Tracking';
             readonly order: 5;
         };
     };
@@ -188,7 +188,7 @@ export declare const ptzAutotrackCapability: {
                 label: z.ZodString;
             }, z.core.$strip>>;
         }, z.core.$strip>;
-        readonly kind: "command-driven";
+        readonly kind: 'command-driven';
     };
     /**
      * Persistent slice mirrored across restarts. The provider writes
@@ -218,6 +218,6 @@ export declare const ptzAutotrackCapability: {
      * See `RuntimeStateDurability`. Enforced by
      * `scripts/check-runtime-state-durability.ts`.
      */
-    readonly durability: "session";
+    readonly durability: 'session';
 };
 export type IPtzAutotrackProvider = InferProvider<typeof ptzAutotrackCapability>;

package/dist/capabilities/ptz.cap.d.ts

@@ -23,28 +23,28 @@ import { DeviceType } from '../device/device-type.js';
  * `deletePreset` are gated.
  */
 export declare const PtzPresetFunctionSchema: z.ZodEnum<{
-    home: "home";
-    reboot: "reboot";
     "day-mode": "day-mode";
-    "night-mode": "night-mode";
     "day-night-auto": "day-night-auto";
-    "set-limits": "set-limits";
-    "save-limits": "save-limits";
+    home: "home";
+    "night-mode": "night-mode";
     "osd-menu": "osd-menu";
+    reboot: "reboot";
+    "save-limits": "save-limits";
+    "set-limits": "set-limits";
 }>;
 export type PtzPresetFunction = z.infer<typeof PtzPresetFunctionSchema>;
 declare const PtzPresetSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
     fn: z.ZodNullable<z.ZodEnum<{
-        home: "home";
-        reboot: "reboot";
         "day-mode": "day-mode";
-        "night-mode": "night-mode";
         "day-night-auto": "day-night-auto";
-        "set-limits": "set-limits";
-        "save-limits": "save-limits";
+        home: "home";
+        "night-mode": "night-mode";
         "osd-menu": "osd-menu";
+        reboot: "reboot";
+        "save-limits": "save-limits";
+        "set-limits": "set-limits";
     }>>;
     writable: z.ZodBoolean;
 }, z.core.$strip>;
@@ -136,10 +136,10 @@ declare const PtzOptionsSchema: z.ZodObject<{
 export declare const PtzHomePresetSchema: z.ZodObject<{
     presetId: z.ZodNullable<z.ZodString>;
     source: z.ZodEnum<{
-        operator: "operator";
-        none: "none";
-        native: "native";
         firmware: "firmware";
+        native: "native";
+        none: "none";
+        operator: "operator";
     }>;
 }, z.core.$strip>;
 export type PtzHomePreset = z.infer<typeof PtzHomePresetSchema>;
@@ -165,18 +165,18 @@ export declare const PtzHomeReturnSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type PtzHomeReturn = z.infer<typeof PtzHomeReturnSchema>;
 export declare const ptzCapability: {
-    readonly name: "ptz";
-    readonly scope: "device";
+    readonly name: 'ptz';
+    readonly scope: 'device';
     readonly deviceNative: true;
-    readonly mode: "singleton";
+    readonly mode: 'singleton';
     readonly deviceTypes: readonly [DeviceType.Camera];
     readonly deviceConfig: {
         readonly ui: {
-            readonly kind: "widget";
-            readonly widgetId: "host/ptz-panel";
-            readonly tab: "ptz";
+            readonly kind: 'widget';
+            readonly widgetId: 'host/ptz-panel';
+            readonly tab: 'ptz';
             readonly topTab: true;
-            readonly label: "PTZ";
+            readonly label: 'PTZ';
             readonly order: 0;
         };
     };
@@ -204,14 +204,14 @@ export declare const ptzCapability: {
             id: z.ZodString;
             name: z.ZodString;
             fn: z.ZodNullable<z.ZodEnum<{
-                home: "home";
-                reboot: "reboot";
                 "day-mode": "day-mode";
-                "night-mode": "night-mode";
                 "day-night-auto": "day-night-auto";
-                "set-limits": "set-limits";
-                "save-limits": "save-limits";
+                home: "home";
+                "night-mode": "night-mode";
                 "osd-menu": "osd-menu";
+                reboot: "reboot";
+                "save-limits": "save-limits";
+                "set-limits": "set-limits";
             }>>;
             writable: z.ZodBoolean;
         }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
@@ -254,10 +254,10 @@ export declare const ptzCapability: {
         }, z.core.$strip>, z.ZodObject<{
             presetId: z.ZodNullable<z.ZodString>;
             source: z.ZodEnum<{
-                operator: "operator";
-                none: "none";
-                native: "native";
                 firmware: "firmware";
+                native: "native";
+                none: "none";
+                operator: "operator";
             }>;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
@@ -344,7 +344,7 @@ export declare const ptzCapability: {
             zoom: z.ZodNullable<z.ZodNumber>;
             autofocus: z.ZodBoolean;
         }, z.core.$strip>;
-        readonly kind: "command-driven";
+        readonly kind: 'command-driven';
     };
 };
 export type IPtzProvider = InferProvider<typeof ptzCapability>;

package/dist/capabilities/reboot.cap.d.ts

@@ -16,10 +16,10 @@ import { DeviceType } from '../device/device-type.js';
  * error to the UI, which renders it next to the button.
  */
 export declare const rebootCapability: {
-    readonly name: "reboot";
-    readonly scope: "device";
+    readonly name: 'reboot';
+    readonly scope: 'device';
     readonly deviceNative: true;
-    readonly mode: "singleton";
+    readonly mode: 'singleton';
     readonly deviceTypes: readonly [DeviceType.Camera, DeviceType.Sensor, DeviceType.Switch];
     readonly methods: {
         readonly reboot: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{