@camstack/types 1.2.406 → 1.2.408

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/composer.cap.d.ts

@@ -123,6 +123,14 @@ export declare const ComposerUnreadableBlockSchema: z.ZodObject<{
     error: z.ZodString;
 }, z.core.$strip>;
 export type ComposerUnreadableBlock = z.infer<typeof ComposerUnreadableBlockSchema>;
+/** A confirmed release the hub did not accept. `deviceId` is the claim's device. */
+export declare const UnreleasedClaimSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    capName: z.ZodString;
+    owner: z.ZodString;
+    error: z.ZodString;
+}, z.core.$strip>;
+export type UnreleasedClaim = z.infer<typeof UnreleasedClaimSchema>;
 export declare const ComposerApplyInputSchema: z.ZodObject<{
     integrationId: z.ZodNullable<z.ZodString>;
     storeLoaded: z.ZodBoolean;
@@ -233,6 +241,7 @@ export declare const ComposerApplyInputSchema: z.ZodObject<{
         name: z.ZodNullable<z.ZodString>;
         error: z.ZodString;
     }, z.core.$strip>>;
+    retiredBlockIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type ComposerApplyInput = z.infer<typeof ComposerApplyInputSchema>;
 export declare const ComposerBlockVerdictSchema: z.ZodObject<{
@@ -260,6 +269,12 @@ export declare const ComposerApplyResultSchema: z.ZodObject<{
         reason: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     acted: z.ZodBoolean;
+    unreleasedClaims: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        deviceId: z.ZodNumber;
+        capName: z.ZodString;
+        owner: z.ZodString;
+        error: z.ZodString;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type ComposerApplyResult = z.infer<typeof ComposerApplyResultSchema>;
 export declare const composerCapability: {
@@ -382,6 +397,7 @@ export declare const composerCapability: {
                 name: z.ZodNullable<z.ZodString>;
                 error: z.ZodString;
             }, z.core.$strip>>;
+            retiredBlockIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>, z.ZodObject<{
             blocks: z.ZodArray<z.ZodObject<{
                 blockId: z.ZodString;
@@ -395,6 +411,12 @@ export declare const composerCapability: {
                 reason: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
             acted: z.ZodBoolean;
+            unreleasedClaims: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                deviceId: z.ZodNumber;
+                capName: z.ZodString;
+                owner: z.ZodString;
+                error: z.ZodString;
+            }, z.core.$strip>>>;
         }, z.core.$strip>, "mutation">;
         readonly getStates: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             blockIds: z.ZodArray<z.ZodString>;

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

@@ -38,7 +38,7 @@ export { cameraStreamsCapability, type ICameraStreamsProvider, type PickedCamStr
 export { emitsCollectionSelector, extractNestedAddonId, isArrayOutputSchema, isCollectionArrayMethod, isObjectInput, isVoidInput, kebabToCamel, looseSchema, objectInputDeclaresAddonId, objectInputDeclaresRequiredDeviceId, procedureAuthKey, resolveMethodAuth, } from './cap-router-predicates.js';
 export type { CapabilityDefinition, CapabilityEventSchema, CapabilityMethodAuth, CapabilityMethodCaller, CapabilityMethodKind, CapabilityMethodOptions, CapabilityMethodSchema, CapabilityMountHint, CapabilityMountKind, CapabilityStatusItemArray, CapabilityStatusKind, CapabilityStatusSchema, CapCaller, DeviceConfigDerivedFormUi, DeviceConfigSpec, DeviceConfigUiSpec, DeviceConfigWidgetUi, DeviceSettingsContribution, InferDeviceProxyCap, InferEvents, InferName, InferNativeProvider, InferProvider, InferRuntimeState, CapabilityHistory, CapabilityHistoryField, CapabilityHistoryItems, HistoryUnit, ProviderKind, RuntimeStateDurability, UiContribution, UiContributionKind, UiContributionRemote, } from './capability-definition.js';
 export { DEFAULT_RUNTIME_STATE_DURABILITY, HISTORY_DEFAULT_MIN_INTERVAL_MS, HISTORY_UNIT_LABELS, historyItemFieldPath, DEVICE_SETTINGS_CONTRIBUTION_METHODS, DEVICE_STATUS_METHOD, event, expandCapMethods, isDeviceConfigCap, method, optionalMethod, PROVIDER_PIN_FIELD, resolveCapMount, } from './capability-definition.js';
-export { COMPOSER_RUNNER_ID, type ComposerApplyInput, ComposerApplyInputSchema, type ComposerApplyResult, ComposerApplyResultSchema, type ComposerBlock, ComposerBlockSchema, type ComposerBlockVerdict, ComposerBlockVerdictSchema, type ComposerUnreadableBlock, ComposerUnreadableBlockSchema, composerCapability, type IComposerProvider, } from './composer.cap.js';
+export { COMPOSER_RUNNER_ID, type ComposerApplyInput, ComposerApplyInputSchema, type ComposerApplyResult, ComposerApplyResultSchema, type ComposerBlock, ComposerBlockSchema, type ComposerBlockVerdict, ComposerBlockVerdictSchema, type ComposerUnreadableBlock, ComposerUnreadableBlockSchema, composerCapability, type IComposerProvider, type UnreleasedClaim, UnreleasedClaimSchema, } from './composer.cap.js';
 export { CORE_BLOCK_ADDON_PREFIX, CORE_BLOCKS_ADDON_ID, type CompositionBlockInput, CompositionBlockInputSchema, type CompositionBlockPatch, type CompositionCustomizationRead, CompositionCustomizationReadSchema, type CompositionGetRead, CompositionGetReadSchema, type CompositionListRead, CompositionListReadSchema, type CompositionStateRead, CompositionStateReadSchema, type CompositionView, CompositionViewSchema, type CoreBlock, type CoreBlockCompileInput, CoreBlockCompileInputSchema, type CoreBlockCompileResult, CoreBlockCompileResultSchema, type CoreBlockFiles, CoreBlockFilesSchema, type CoreBlockInput, CoreBlockInputFieldsSchema, CoreBlockInputSchema, type CoreBlockPlacement, CoreBlockPlacementSchema, CoreBlockSchema, type CoreBlockSource, type CoreBlockSourceKind, CoreBlockSourceSchema, type CoreBlockStatus, CoreBlockStatusSchema, coreBlockAddonId, coreBlockComposition, coreBlockIdFromAddonId, coreBlockSourceKind, coreBlocksCapability, DEFAULT_CORE_BLOCK_ENTRY, type ICoreBlocksProvider, normalizeCoreBlockWrite, resolveCoreBlockEntry, resolveCoreBlockFiles, } from './core-blocks.cap.js';
 export * from './custom-actions.js';
 export type { CustomModelDescriptor, ICustomModelRegistryProvider, ImportModelBundleInput, ImportModelBundleResult, ModelBundleFile, } from './custom-model-registry.cap.js';
@@ -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>;