@camstack/types 1.2.406 → 1.2.407

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

@@ -160,6 +160,52 @@ export declare const batteryCapability: {
             };
         };
     };
+    readonly customize: {
+        readonly version: 1;
+        readonly targets: readonly [{
+            readonly id: 'percentage';
+            readonly cardinality: 'scalar';
+            readonly vocabulary: {
+                readonly cap: 'battery';
+                readonly stateField: 'percentage';
+            };
+            readonly deviceTypes: readonly [DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch, DeviceType.PetFeeder, DeviceType.Container, DeviceType.Thermostat];
+            readonly apply: 'add-or-replace';
+            readonly path: 'percentage';
+            readonly sources: readonly [{
+                readonly kind: 'field';
+                readonly valueKinds: readonly ["number", "string"];
+                readonly transforms: readonly [{
+                    readonly kind: 'identity';
+                }, {
+                    readonly kind: 'linear';
+                    readonly defaultScale: 1;
+                    readonly defaultOffset: 0;
+                    readonly clampMin: 0;
+                    readonly clampMax: 100;
+                }];
+            }];
+            readonly companions: readonly [{
+                readonly kind: 'constant';
+                readonly path: 'charging';
+                readonly value: 'unknown';
+                readonly when: 'add';
+            }, {
+                readonly kind: 'constant';
+                readonly path: 'sleeping';
+                readonly value: false;
+                readonly when: 'add';
+            }, {
+                readonly kind: 'clock';
+                readonly path: 'lastUpdated';
+                readonly when: 'add';
+            }];
+            readonly sourceReport: {
+                readonly status: 'assignment-status';
+            };
+            readonly advancedExpression: true;
+        }];
+    };
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastUpdated"];

package/dist/capabilities/capability-definition.d.ts

@@ -16,6 +16,7 @@ import { DeviceType } from '../device/device-type.js';
 import type { ConfigUISchemaWithValues } from '../interfaces/config-ui.js';
 import type { ExtensionSlotDescriptor } from '../device-extension/slot-descriptor.js';
 import type { MethodRoleDecl } from '../auth/viewer-access.js';
+import type { CapabilityCustomizeSpec } from './customize-spec.js';
 /**
  * tRPC procedure kind.
  * - 'query': read-only, no side effects
@@ -650,6 +651,13 @@ export interface CapabilityDefinition<TName extends string = string, TMethods ex
      * `generated/history-catalog.ts`.
      */
     readonly history?: CapabilityHistory;
+    /**
+     * Generic Customize override (D936). When present, admin-ui offers the
+     * declared targets instead of a cap-specific card. Codegen projects it
+     * into `generated/customize-catalog.ts`. `scripts/check-customize-declaration.ts`
+     * rejects a path, type or vocabulary the cap does not have.
+     */
+    readonly customize?: CapabilityCustomizeSpec;
     /**
      * Declarative settings spec. When present, the device-manager's
      * settings aggregator auto-derives the ConfigUISchema and routes

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

@@ -378,6 +378,116 @@ export declare const consumablesCapability: {
      * brush's remaining life and a dishwasher's salt are each recorded the moment
      * their provider reports them; an item that appears later gets its series.
      */
+    readonly customize: {
+        version: 1;
+        targets: {
+            id: string;
+            cardinality: "keyedArray";
+            vocabulary: {
+                cap: string;
+            };
+            deviceTypes: DeviceType[];
+            apply: "add";
+            path: string;
+            keyField: string;
+            labelField: string;
+            itemSchema: z.ZodObject<{
+                key: z.ZodString;
+                label: z.ZodString;
+                level: z.ZodNullable<z.ZodNumber>;
+                status: z.ZodNullable<z.ZodEnum<{
+                    empty: "empty";
+                    full: "full";
+                    low: "low";
+                    ok: "ok";
+                    replace: "replace";
+                }>>;
+                kind: z.ZodOptional<z.ZodEnum<{
+                    supply: "supply";
+                    waste: "waste";
+                    wear: "wear";
+                }>>;
+                form: z.ZodOptional<z.ZodEnum<{
+                    bin: "bin";
+                    part: "part";
+                    product: "product";
+                    tank: "tank";
+                }>>;
+                lastResetAt: z.ZodNullable<z.ZodNumber>;
+                resettable: z.ZodBoolean;
+                remaining: z.ZodOptional<z.ZodObject<{
+                    value: z.ZodNullable<z.ZodNumber>;
+                    unit: z.ZodEnum<{
+                        cycles: "cycles";
+                        days: "days";
+                        hours: "hours";
+                    }>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            nativeItems: "read-only";
+            sourceReport: {
+                status: "assignment-status";
+            };
+            fields: ({
+                path: string;
+                sources: {
+                    kind: "numeric";
+                    transforms: ({
+                        kind: "identity";
+                        defaultScale?: undefined;
+                        defaultOffset?: undefined;
+                        clampMin?: undefined;
+                        clampMax?: undefined;
+                    } | {
+                        kind: "linear";
+                        defaultScale: number;
+                        defaultOffset: number;
+                        clampMin: number;
+                        clampMax: number;
+                    })[];
+                }[];
+                literals?: undefined;
+            } | {
+                path: string;
+                sources: {
+                    kind: "numeric";
+                    transforms: {
+                        kind: "identity";
+                    }[];
+                }[];
+                literals: {
+                    path: string;
+                    values: ("cycles" | "days" | "hours")[];
+                }[];
+            } | {
+                literals?: undefined;
+                path: string;
+                sources: {
+                    kind: "enum";
+                    transforms: {
+                        kind: "enum-map";
+                        outputValues: ("empty" | "full" | "low" | "ok" | "replace")[];
+                        unmapped: null;
+                    }[];
+                }[];
+            })[];
+            traits: ({
+                path: string;
+                values: ("supply" | "waste" | "wear")[];
+                defaultValue: string;
+            } | {
+                path: string;
+                values: ("bin" | "part" | "product" | "tank")[];
+                defaultValue: string;
+            })[];
+            companions: {
+                kind: "clock";
+                path: string;
+                when: "add";
+            }[];
+            advancedExpression: true;
+        }[];
+    };
     readonly history: {
         readonly fields: {};
         readonly items: {

package/dist/capabilities/customize-catalog.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Serializable Customize catalog (D936). No Zod objects: admin-ui and the
+ * server read this projection, not the cap module.
+ */
+import type { DeviceType } from '../device/device-type.js';
+import type { CameraSensorCustomizeMode, CustomizeApplyAuthority, CustomizeApplyMode, CustomizeCardinality, CustomizeCompanion, CustomizeEventEdge, CustomizeSourceReport, CustomizeValueKind } from './customize-spec.js';
+export type CustomizeCatalogValueKind = 'boolean' | 'number' | 'string' | 'enum';
+export interface CustomizeCatalogSource {
+    readonly kind: string;
+    readonly valueKinds?: readonly CustomizeValueKind[];
+    readonly transformKinds: readonly string[];
+    readonly requiredUnit?: string;
+}
+export interface CustomizeCatalogLiteral {
+    readonly path: string;
+    readonly values: readonly string[];
+}
+export interface CustomizeCatalogTrait {
+    readonly path: string;
+    readonly values: readonly string[];
+    readonly defaultValue: string;
+}
+export interface CustomizeCatalogField {
+    readonly path: string;
+    readonly valueKind: CustomizeCatalogValueKind;
+    readonly nullable: boolean;
+    readonly enumValues?: readonly string[];
+    readonly sources: readonly CustomizeCatalogSource[];
+    readonly literals?: readonly CustomizeCatalogLiteral[];
+}
+export interface CustomizeCatalogTarget {
+    readonly id: string;
+    readonly cardinality: CustomizeCardinality;
+    readonly shape?: 'pulse' | 'span';
+    readonly path?: string;
+    readonly valueKind?: CustomizeCatalogValueKind;
+    readonly nullable?: boolean;
+    readonly enumValues?: readonly string[];
+    readonly keyField?: string;
+    readonly labelField?: string;
+    readonly fields?: readonly CustomizeCatalogField[];
+    readonly traits?: readonly CustomizeCatalogTrait[];
+    readonly nativeItems?: 'read-only';
+    readonly deviceTypes: readonly DeviceType[];
+    readonly apply: CustomizeApplyMode;
+    /** Absent on a scalar or keyed array: those compile to a composition claim. */
+    readonly applyAuthority?: CustomizeApplyAuthority;
+    readonly eventName?: string;
+    readonly edges?: readonly CustomizeEventEdge[];
+    readonly timestampPath?: string;
+    readonly counterPath?: string;
+    readonly highWater?: 'composer-advance';
+    readonly debounceMs?: number;
+    readonly combine?: 'any';
+    readonly timeoutMs?: number;
+    readonly cooldownMs?: number;
+    readonly sourceModes?: readonly CameraSensorCustomizeMode[];
+    readonly start?: 'rising-edge';
+    readonly end?: 'falling-edge-or-timeout';
+    readonly vocabularyCap: string;
+    readonly vocabularyStateField?: string;
+    readonly vocabularyEvent?: string;
+    readonly sources: readonly CustomizeCatalogSource[];
+    readonly companions?: readonly CustomizeCompanion[];
+    readonly sourceReport: CustomizeSourceReport;
+    readonly advancedExpression: boolean;
+}
+export interface CustomizeCatalogEntry {
+    readonly version: 1;
+    readonly targets: readonly CustomizeCatalogTarget[];
+}
+export type CustomizeCatalog = Readonly<Record<string, CustomizeCatalogEntry>>;

package/dist/capabilities/customize-spec.d.ts

@@ -0,0 +1,202 @@
+/**
+ * Cap-declared Customize contract (D936).
+ *
+ * A declaration says what an operator may pick and how the result lands.
+ * Codegen projects the serializable catalog; Zod stays in this module and
+ * never in the catalog. Names follow the approved design.
+ */
+import type { z } from 'zod';
+import type { DeviceType } from '../device/device-type.js';
+export type CustomizeCardinality = 'scalar' | 'keyedArray' | 'event';
+export type CustomizeValueKind = 'boolean' | 'number' | 'string' | 'enum';
+export type CustomizeApplyMode = 'add' | 'replace' | 'add-or-replace';
+export interface CapabilityCustomizeSpec {
+    readonly version: 1;
+    readonly targets: readonly CapabilityCustomizeTarget[];
+}
+export type CapabilityCustomizeTarget = ScalarCustomizeTarget | KeyedArrayCustomizeTarget | EventCustomizeTarget;
+export interface CustomizeVocabularyRef {
+    readonly cap: string;
+    readonly stateField?: string;
+    readonly eventName?: string;
+}
+export interface CustomizeTargetBase {
+    readonly id: string;
+    readonly vocabulary: CustomizeVocabularyRef;
+    readonly deviceTypes?: readonly DeviceType[];
+    readonly apply: CustomizeApplyMode;
+    readonly sourceReport: CustomizeSourceReport;
+    readonly advancedExpression?: boolean;
+}
+export type CustomizeSourceSpec = SwitchSourceSpec | BinarySourceSpec | NumericSourceSpec | EnumSourceSpec | FieldSourceSpec;
+export interface SwitchSourceSpec {
+    readonly kind: 'switch';
+    readonly transforms: readonly SwitchTransformSpec[];
+}
+export interface BinarySourceSpec {
+    readonly kind: 'binary';
+    readonly transforms: readonly BinaryTransformSpec[];
+}
+export interface NumericSourceSpec {
+    readonly kind: 'numeric';
+    readonly requiredUnit?: string;
+    readonly transforms: readonly NumericTransformSpec[];
+}
+export interface EnumSourceSpec {
+    readonly kind: 'enum';
+    readonly transforms: readonly EnumTransformSpec[];
+}
+export interface FieldSourceSpec {
+    readonly kind: 'field';
+    readonly valueKinds: readonly CustomizeValueKind[];
+    readonly transforms: readonly CustomizeTransformSpec[];
+}
+export interface IdentityTransformSpec {
+    readonly kind: 'identity';
+}
+export interface InvertTransformSpec {
+    readonly kind: 'invert';
+}
+export interface ThresholdTransformSpec {
+    readonly kind: 'threshold';
+    readonly comparison: 'gte' | 'lte';
+    readonly defaultThreshold: number;
+    readonly defaultStartDwellMs: number;
+    readonly defaultStopDwellMs: number;
+    readonly thresholdUnit?: string;
+}
+export interface LinearTransformSpec {
+    readonly kind: 'linear';
+    readonly defaultScale: number;
+    readonly defaultOffset: number;
+    readonly clampMin?: number;
+    readonly clampMax?: number;
+}
+export interface EnumMapTransformSpec {
+    readonly kind: 'enum-map';
+    readonly outputValues: readonly string[];
+    readonly unmapped: null | string;
+}
+export interface RisingEdgeTransformSpec {
+    readonly kind: 'rising-edge';
+    readonly defaultDebounceMs: number;
+    readonly changedAtRequired: true;
+}
+export type SwitchTransformSpec = IdentityTransformSpec;
+export type BinaryTransformSpec = IdentityTransformSpec | InvertTransformSpec;
+/** A pulse or span reads a level, or an event the source cap already emits. */
+export interface EventSourceSpec {
+    readonly kind: 'switch' | 'binary' | 'native-event';
+}
+export type CustomizeEventEdge = 'rising' | 'button' | 'native-event';
+/**
+ * Where the compiled target is written. Scalar and keyed-array targets use a
+ * composition claim. A span may name an authority that already owns the event.
+ */
+export type CustomizeApplyAuthority = {
+    readonly kind: 'composition-claim';
+} | {
+    readonly kind: 'camera-sensors';
+    /** The span timeout is this existing pipeline-runner field. */
+    readonly timeoutField: 'motionCooldownMs';
+};
+export type NumericTransformSpec = IdentityTransformSpec | ThresholdTransformSpec | LinearTransformSpec;
+export type EnumTransformSpec = IdentityTransformSpec | EnumMapTransformSpec;
+export type CustomizeTransformSpec = IdentityTransformSpec | InvertTransformSpec | ThresholdTransformSpec | LinearTransformSpec | EnumMapTransformSpec;
+export interface CustomizeSourceReport {
+    readonly status: 'assignment-status';
+    readonly runtimeField?: string;
+    readonly nativeValue?: string;
+    readonly assignedValue?: string;
+}
+export type CustomizeCompanion = CustomizeConstantCompanion | CustomizeClockCompanion | CustomizeTransitionTimeCompanion;
+export interface CustomizeConstantCompanion {
+    readonly kind: 'constant';
+    readonly path: string;
+    readonly value: string | number | boolean | null;
+    readonly when: 'add' | 'always';
+}
+export interface CustomizeClockCompanion {
+    readonly kind: 'clock';
+    readonly path: string;
+    readonly when: 'add' | 'always';
+}
+export interface CustomizeTransitionTimeCompanion {
+    readonly kind: 'transition-time';
+    readonly path: string;
+    readonly sourceChangedAt: 'prefer' | 'ignore';
+}
+export interface ScalarCustomizeTarget extends CustomizeTargetBase {
+    readonly cardinality: 'scalar';
+    readonly path: string;
+    readonly sources: readonly CustomizeSourceSpec[];
+    readonly companions?: readonly CustomizeCompanion[];
+}
+/** A closed enum the operator sets on the item. It is not read from a source. */
+export interface KeyedArrayTraitSpec {
+    readonly path: string;
+    readonly values: readonly string[];
+    readonly defaultValue: string;
+}
+/** A closed enum written beside one assigned field (the field's required sibling). */
+export interface KeyedArrayLiteralSpec {
+    readonly path: string;
+    readonly values: readonly string[];
+}
+export interface KeyedArrayFieldTarget {
+    readonly path: string;
+    readonly sources: readonly CustomizeSourceSpec[];
+    readonly literals?: readonly KeyedArrayLiteralSpec[];
+}
+export interface KeyedArrayCustomizeTarget extends CustomizeTargetBase {
+    /**
+     * Row schema. Zod stays on the declaration; the catalog projects paths
+     * and leaf kinds instead of this object. Loose so a specific item schema
+     * assigns (Zod 4 raw shapes do not).
+     */
+    readonly itemSchema: z.ZodObject<z.core.$ZodLooseShape>;
+    readonly cardinality: 'keyedArray';
+    readonly path: string;
+    readonly keyField: string;
+    readonly labelField: string;
+    readonly fields: readonly KeyedArrayFieldTarget[];
+    readonly traits?: readonly KeyedArrayTraitSpec[];
+    readonly companions?: readonly CustomizeCompanion[];
+    readonly nativeItems: 'read-only';
+}
+export interface EventCustomizeTargetBase extends CustomizeTargetBase {
+    readonly cardinality: 'event';
+    readonly eventName: string;
+    /** One source firing is enough. */
+    readonly combine: 'any';
+    readonly sources: readonly EventSourceSpec[];
+    readonly applyAuthority: CustomizeApplyAuthority;
+}
+/**
+ * A pulse has no duration. A rising edge, a button press or a native event
+ * advances a timestamp and a counter. Presses inside `debounce` are one pulse.
+ */
+export interface PulseEventCustomizeTarget extends EventCustomizeTargetBase {
+    readonly shape: 'pulse';
+    readonly edges: readonly CustomizeEventEdge[];
+    readonly timestampPath: string;
+    readonly counterPath: string;
+    /** The composer already tracks this path's advance (D670). */
+    readonly highWater: 'composer-advance';
+    readonly debounce: RisingEdgeTransformSpec;
+}
+export type CameraSensorCustomizeMode = 'in-addition' | 'confirm' | 'replace';
+/**
+ * A span starts on a rising edge and ends on a falling edge or when
+ * `timeoutMs` elapses. `cooldownMs` is present only when the authority has a
+ * quiet period that is not the timeout.
+ */
+export interface SpanEventCustomizeTarget extends EventCustomizeTargetBase {
+    readonly shape: 'span';
+    readonly start: 'rising-edge';
+    readonly end: 'falling-edge-or-timeout';
+    readonly timeoutMs: number;
+    readonly cooldownMs?: number;
+    readonly sourceModes?: readonly CameraSensorCustomizeMode[];
+}
+export type EventCustomizeTarget = PulseEventCustomizeTarget | SpanEventCustomizeTarget;

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

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import { type InferProvider } from './capability-definition.js';
 import { DeviceType } from '../device/device-type.js';
+/** A rise closer than this to the previous one is the same press (D671). */
+export declare const DOORBELL_RISE_DEBOUNCE_MS = 2000;
 export declare const DoorbellStatusSchema: z.ZodObject<{
     lastPressedAt: z.ZodNullable<z.ZodNumber>;
     pressCountSinceStart: z.ZodNumber;
@@ -78,5 +80,42 @@ export declare const doorbellCapability: {
      * History (D850): none — `pressCountSinceStart` resets with the addon, so it is not a monotonic meter; presses live in the events ledger.
      */
     readonly history: 'none';
+    readonly customize: {
+        readonly version: 1;
+        readonly targets: readonly [{
+            readonly id: 'pressed';
+            readonly cardinality: 'event';
+            readonly shape: 'pulse';
+            readonly vocabulary: {
+                readonly cap: 'doorbell';
+                readonly eventName: 'onPressed';
+            };
+            readonly deviceTypes: readonly [DeviceType.Camera];
+            readonly apply: 'add';
+            readonly applyAuthority: {
+                readonly kind: 'composition-claim';
+            };
+            readonly eventName: 'onPressed';
+            readonly edges: readonly ["rising"];
+            readonly timestampPath: 'lastPressedAt';
+            readonly counterPath: 'pressCountSinceStart';
+            readonly highWater: 'composer-advance';
+            readonly combine: 'any';
+            readonly debounce: {
+                readonly kind: 'rising-edge';
+                readonly defaultDebounceMs: 2000;
+                readonly changedAtRequired: true;
+            };
+            readonly sources: readonly [{
+                readonly kind: 'binary';
+            }, {
+                readonly kind: 'switch';
+            }];
+            readonly sourceReport: {
+                readonly status: 'assignment-status';
+            };
+            readonly advancedExpression: true;
+        }];
+    };
 };
 export type IDoorbellProvider = InferProvider<typeof doorbellCapability>;

package/dist/capabilities/index.d.ts

@@ -176,7 +176,7 @@ export { type DeviceDiscoveryStatus, DeviceDiscoveryStatusSchema, type Discovere
 export { deviceOpsCapability, type IDeviceOpsProvider, type RawStateResult, RawStateResultSchema, } from './device-ops.cap.js';
 export { type DeviceStatus, DeviceStatusSchema, deviceStatusCapability, type IDeviceStatusProvider, } from './device-status.cap.js';
 export { type DishwasherAccess, DishwasherAccessSchema, type DishwasherAvailability, DishwasherAvailabilitySchema, type DishwasherOperationState, DishwasherOperationStateSchema, type DishwasherOptionDescriptor, DishwasherOptionDescriptorSchema, type DishwasherOptions, DishwasherOptionsSchema, type DishwasherProgram, DishwasherProgramSchema, type DishwasherState, DishwasherStateSchema, type DishwasherStatus, DishwasherStatusSchema, type DishwasherValue, DishwasherValueSchema, dishwasherCapability, type IDishwasherProvider, } from './dishwasher.cap.js';
-export { type DoorbellPressEvent, DoorbellPressEventSchema, type DoorbellStatus, DoorbellStatusSchema, doorbellCapability, type IDoorbellProvider, } from './doorbell.cap.js';
+export { DOORBELL_RISE_DEBOUNCE_MS, type DoorbellPressEvent, DoorbellPressEventSchema, type DoorbellStatus, DoorbellStatusSchema, doorbellCapability, type IDoorbellProvider, } from './doorbell.cap.js';
 export { type EnumSensorDateTimeFormat, EnumSensorDateTimeFormatSchema, type EnumSensorStatus, EnumSensorStatusSchema, enumSensorCapability, type IEnumSensorProvider, } from './enum-sensor.cap.js';
 export { type EventEmitterStatus, EventEmitterStatusSchema, type EventFire, EventFireSchema, eventEmitterCapability, type IEventEmitterProvider, } from './event-emitter.cap.js';
 export { type FaceCluster, type FaceInfo, type FaceSortDirection, type FaceSortField, faceGalleryCapability, type Identity, type IdentitySampleAudit, type IdentitySampleAuditRow, type IdentitySampleInfo, type IFaceGalleryProvider, type ListRecentFacesInput, type SuggestFaceClustersInput, } from './face-gallery.cap.js';
@@ -197,7 +197,7 @@ export { type ILockControlProvider, type LockControlStatus, LockControlStatusSch
 export { type MaskGridDims, MaskGridDimsSchema, type MaskGridShape, MaskGridShapeSchema, type MaskLineShape, MaskLineShapeSchema, type MaskPoint, MaskPointSchema, type MaskPolygonShape, MaskPolygonShapeSchema, type MaskPolygonVertices, MaskPolygonVerticesSchema, type MaskRectShape, MaskRectShapeSchema, type MaskShape, type MaskShapeKind, MaskShapeKindSchema, MaskShapeSchema, } from './mask-shape.js';
 export { type IMediaPlayerProvider, type MediaInfo, type MediaPlayerRepeat, MediaPlayerRepeatSchema, type MediaPlayerState, MediaPlayerStateSchema, type MediaPlayerStatus, MediaPlayerStatusSchema, mediaPlayerCapability, } from './media-player.cap.js';
 export { type IMeshNetworkProvider, type MeshEndpoint, type MeshPeer, MeshPeerSchema, type MeshStatus, MeshStatusSchema, meshNetworkCapability, } from './mesh-network.cap.js';
-export { type IMotionProvider, MOTION_CLOSE_AFTER_MS, type MotionOnMotionChangedData, MotionOnMotionChangedDataSchema, type MotionStatus, MotionStatusSchema, motionCapability, } from './motion.cap.js';
+export { type IMotionProvider, MOTION_CLOSE_AFTER_MS, MOTION_SPAN_TIMEOUT_MS, type MotionOnMotionChangedData, MotionOnMotionChangedDataSchema, type MotionStatus, MotionStatusSchema, motionCapability, } from './motion.cap.js';
 export { type IMotionTriggerProvider, type MotionTriggerRuntimeState, MotionTriggerRuntimeStateSchema, type MotionTriggerStatus, MotionTriggerStatusSchema, motionTriggerCapability, } from './motion-trigger.cap.js';
 export { type IMotionZonesProvider, type MotionZoneOptions, MotionZoneOptionsSchema, type MotionZonePatch, MotionZonePatchSchema, type MotionZoneRegion, MotionZoneRegionSchema, type MotionZoneStatus, MotionZoneStatusSchema, motionZonesCapability, } from './motion-zones.cap.js';
 export { type INativeObjectDetectionProvider, type NativeDetection, NativeDetectionSchema, type NativeObjectClass, NativeObjectClassEnum, type NativeObjectDetectionOptions, NativeObjectDetectionOptionsSchema, type NativeObjectDetectionRuntimeState, NativeObjectDetectionRuntimeStateSchema, type NativeObjectDetectionSettingsPatch, NativeObjectDetectionSettingsPatchSchema, type NativeObjectDetectionStatus, NativeObjectDetectionStatusSchema, type NativeObjectGeometry, NativeObjectGeometryEnum, nativeObjectDetectionCapability, } from './native-object-detection.cap.js';

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

@@ -1,6 +1,12 @@
 import { z } from 'zod';
 import { DeviceType } from '../device/device-type.js';
 import { type InferProvider } from './capability-definition.js';
+/**
+ * Span timeout for a camera's attached sensors. This is the pipeline-runner
+ * `motionCooldownMs` default: the window after which a heartbeat-only edge
+ * no longer counts. The span does not declare a separate cooldown.
+ */
+export declare const MOTION_SPAN_TIMEOUT_MS = 30000;
 /**
  * Hardware / firmware motion sensor cap — binary detected state plus
  * a timestamp of the last observation. Distinct from
@@ -179,5 +185,38 @@ export declare const motionCapability: {
             };
         };
     };
+    readonly customize: {
+        readonly version: 1;
+        readonly targets: readonly [{
+            readonly id: 'detected';
+            readonly cardinality: 'event';
+            readonly shape: 'span';
+            readonly vocabulary: {
+                readonly cap: 'motion';
+                readonly eventName: 'onMotionChanged';
+            };
+            readonly deviceTypes: readonly [DeviceType.Camera];
+            readonly apply: 'replace';
+            readonly applyAuthority: {
+                readonly kind: 'camera-sensors';
+                readonly timeoutField: 'motionCooldownMs';
+            };
+            readonly eventName: 'onMotionChanged';
+            readonly start: 'rising-edge';
+            readonly end: 'falling-edge-or-timeout';
+            readonly timeoutMs: 30000;
+            readonly combine: 'any';
+            readonly sourceModes: readonly ["in-addition", "confirm", "replace"];
+            readonly sources: readonly [{
+                readonly kind: 'binary';
+            }, {
+                readonly kind: 'switch';
+            }];
+            readonly sourceReport: {
+                readonly status: 'assignment-status';
+            };
+            readonly advancedExpression: false;
+        }];
+    };
 };
 export type IMotionProvider = InferProvider<typeof motionCapability>;