@matterbridge/core 3.6.0-dev-20260302-e3a7eb0 → 3.6.0-dev-20260303-f33e36a

package/dist/clusters/closure-control.js

@@ -0,0 +1,170 @@
+import { Attribute, ClusterRegistry, Command, Event, EventPriority, FixedAttribute, MutableCluster, TlvNoResponse } from '@matter/types/cluster';
+import { BitFlag } from '@matter/types/schema';
+import { TlvArray, TlvBitmap, TlvBoolean, TlvEnum, TlvField, TlvNoArguments, TlvNullable, TlvObject, TlvOptionalField, TlvUInt8, TlvUInt32, } from '@matter/types/tlv';
+export var ClosureControl;
+(function (ClosureControl) {
+    let Feature;
+    (function (Feature) {
+        Feature["Positioning"] = "Positioning";
+        Feature["MotionLatching"] = "MotionLatching";
+        Feature["Instantaneous"] = "Instantaneous";
+        Feature["Speed"] = "Speed";
+        Feature["Ventilation"] = "Ventilation";
+        Feature["Pedestrian"] = "Pedestrian";
+        Feature["Calibration"] = "Calibration";
+        Feature["Protection"] = "Protection";
+        Feature["ManuallyOperable"] = "ManuallyOperable";
+    })(Feature = ClosureControl.Feature || (ClosureControl.Feature = {}));
+    let ClosureError;
+    (function (ClosureError) {
+        ClosureError[ClosureError["PhysicallyBlocked"] = 0] = "PhysicallyBlocked";
+        ClosureError[ClosureError["BlockedBySensor"] = 1] = "BlockedBySensor";
+        ClosureError[ClosureError["TemperatureLimited"] = 2] = "TemperatureLimited";
+        ClosureError[ClosureError["MaintenanceRequired"] = 3] = "MaintenanceRequired";
+        ClosureError[ClosureError["InternalInterference"] = 4] = "InternalInterference";
+    })(ClosureError = ClosureControl.ClosureError || (ClosureControl.ClosureError = {}));
+    let CurrentPosition;
+    (function (CurrentPosition) {
+        CurrentPosition[CurrentPosition["FullyClosed"] = 0] = "FullyClosed";
+        CurrentPosition[CurrentPosition["FullyOpened"] = 1] = "FullyOpened";
+        CurrentPosition[CurrentPosition["PartiallyOpened"] = 2] = "PartiallyOpened";
+        CurrentPosition[CurrentPosition["OpenedForPedestrian"] = 3] = "OpenedForPedestrian";
+        CurrentPosition[CurrentPosition["OpenedForVentilation"] = 4] = "OpenedForVentilation";
+        CurrentPosition[CurrentPosition["OpenedAtSignature"] = 5] = "OpenedAtSignature";
+    })(CurrentPosition = ClosureControl.CurrentPosition || (ClosureControl.CurrentPosition = {}));
+    let MainState;
+    (function (MainState) {
+        MainState[MainState["Stopped"] = 0] = "Stopped";
+        MainState[MainState["Moving"] = 1] = "Moving";
+        MainState[MainState["WaitingForMotion"] = 2] = "WaitingForMotion";
+        MainState[MainState["Error"] = 3] = "Error";
+        MainState[MainState["Calibrating"] = 4] = "Calibrating";
+        MainState[MainState["Protected"] = 5] = "Protected";
+        MainState[MainState["Disengaged"] = 6] = "Disengaged";
+        MainState[MainState["SetupRequired"] = 7] = "SetupRequired";
+    })(MainState = ClosureControl.MainState || (ClosureControl.MainState = {}));
+    let TargetPosition;
+    (function (TargetPosition) {
+        TargetPosition[TargetPosition["MoveToFullyClosed"] = 0] = "MoveToFullyClosed";
+        TargetPosition[TargetPosition["MoveToFullyOpen"] = 1] = "MoveToFullyOpen";
+        TargetPosition[TargetPosition["MoveToPedestrianPosition"] = 2] = "MoveToPedestrianPosition";
+        TargetPosition[TargetPosition["MoveToVentilationPosition"] = 3] = "MoveToVentilationPosition";
+        TargetPosition[TargetPosition["MoveToSignaturePosition"] = 4] = "MoveToSignaturePosition";
+    })(TargetPosition = ClosureControl.TargetPosition || (ClosureControl.TargetPosition = {}));
+    ClosureControl.LatchControlModes = {
+        remoteLatching: BitFlag(0),
+        remoteUnlatching: BitFlag(1),
+    };
+    ClosureControl.TlvOverallCurrentState = TlvObject({
+        position: TlvOptionalField(0, TlvNullable(TlvEnum())),
+        latch: TlvOptionalField(1, TlvNullable(TlvBoolean)),
+        speed: TlvOptionalField(2, TlvEnum()),
+        secureState: TlvOptionalField(3, TlvNullable(TlvBoolean)),
+    });
+    ClosureControl.TlvOverallTargetState = TlvObject({
+        position: TlvOptionalField(0, TlvNullable(TlvEnum())),
+        latch: TlvOptionalField(1, TlvNullable(TlvBoolean)),
+        speed: TlvOptionalField(2, TlvEnum()),
+    });
+    ClosureControl.TlvMoveToRequest = TlvObject({
+        position: TlvOptionalField(0, TlvEnum()),
+        latch: TlvOptionalField(1, TlvBoolean),
+        speed: TlvOptionalField(2, TlvEnum()),
+    });
+    ClosureControl.TlvOperationalErrorEvent = TlvObject({
+        errorState: TlvField(0, TlvArray(TlvEnum(), { minLength: 1, maxLength: 10 })),
+    });
+    ClosureControl.TlvEngageStateChangedEvent = TlvObject({
+        engageValue: TlvField(0, TlvBoolean),
+    });
+    ClosureControl.TlvSecureStateChangedEvent = TlvObject({
+        secureValue: TlvField(0, TlvBoolean),
+    });
+    ClosureControl.CountdownTimeComponent = MutableCluster.Component({
+        attributes: {
+            countdownTime: Attribute(0x0, TlvNullable(TlvUInt32.bound({ max: 259200 })), { default: null }),
+        },
+    });
+    ClosureControl.MotionLatchingComponent = MutableCluster.Component({
+        attributes: {
+            latchControlModes: FixedAttribute(0x5, TlvBitmap(TlvUInt8, ClosureControl.LatchControlModes)),
+        },
+    });
+    ClosureControl.CalibrationComponent = MutableCluster.Component({
+        commands: {
+            calibrate: Command(0x2, TlvNoArguments, 0x2, TlvNoResponse, { timed: true }),
+        },
+    });
+    ClosureControl.ManuallyOperableComponent = MutableCluster.Component({
+        events: {
+            engageStateChanged: Event(0x2, EventPriority.Info, ClosureControl.TlvEngageStateChangedEvent),
+        },
+    });
+    ClosureControl.NonInstantaneousComponent = MutableCluster.Component({
+        commands: {
+            stop: Command(0x0, TlvNoArguments, 0x0, TlvNoResponse),
+        },
+        events: {
+            movementCompleted: Event(0x1, EventPriority.Info, TlvNoArguments),
+        },
+    });
+    ClosureControl.Base = MutableCluster.Component({
+        id: 0x0104,
+        name: 'ClosureControl',
+        revision: 1,
+        features: {
+            positioning: BitFlag(0),
+            motionLatching: BitFlag(1),
+            instantaneous: BitFlag(2),
+            speed: BitFlag(3),
+            ventilation: BitFlag(4),
+            pedestrian: BitFlag(5),
+            calibration: BitFlag(6),
+            protection: BitFlag(7),
+            manuallyOperable: BitFlag(8),
+        },
+        attributes: {
+            mainState: Attribute(0x1, TlvEnum()),
+            currentErrorList: Attribute(0x2, TlvArray(TlvEnum(), { maxLength: 10 }), { default: [] }),
+            overallCurrentState: Attribute(0x3, TlvNullable(ClosureControl.TlvOverallCurrentState), { default: null }),
+            overallTargetState: Attribute(0x4, TlvNullable(ClosureControl.TlvOverallTargetState), { default: null }),
+        },
+        commands: {
+            moveTo: Command(0x1, ClosureControl.TlvMoveToRequest, 0x1, TlvNoResponse, { timed: true }),
+        },
+        events: {
+            operationalError: Event(0x0, EventPriority.Critical, ClosureControl.TlvOperationalErrorEvent),
+            secureStateChanged: Event(0x3, EventPriority.Info, ClosureControl.TlvSecureStateChangedEvent),
+        },
+        extensions: MutableCluster.Extensions({ flags: { instantaneous: false }, component: ClosureControl.NonInstantaneousComponent }, { flags: { motionLatching: true }, component: ClosureControl.MotionLatchingComponent }, { flags: { calibration: true }, component: ClosureControl.CalibrationComponent }, { flags: { manuallyOperable: true }, component: ClosureControl.ManuallyOperableComponent }, { flags: { positioning: true, instantaneous: false }, component: ClosureControl.CountdownTimeComponent }, { flags: { positioning: false, motionLatching: false }, component: false }, { flags: { speed: true, positioning: false }, component: false }, { flags: { speed: true, instantaneous: true }, component: false }, { flags: { ventilation: true, positioning: false }, component: false }, { flags: { pedestrian: true, positioning: false }, component: false }, { flags: { calibration: true, positioning: false }, component: false }),
+    });
+    ClosureControl.Cluster = MutableCluster.ExtensibleOnly(ClosureControl.Base);
+    const LT = { motionLatching: true };
+    const CL = { calibration: true };
+    const MO = { manuallyOperable: true };
+    const PS_NOT_IS = { positioning: true, instantaneous: false };
+    const NOT_IS = { instantaneous: false };
+    ClosureControl.Complete = MutableCluster({
+        id: ClosureControl.Base.id,
+        name: ClosureControl.Base.name,
+        revision: ClosureControl.Base.revision,
+        features: ClosureControl.Base.features,
+        attributes: {
+            ...ClosureControl.Base.attributes,
+            countdownTime: MutableCluster.AsConditional(ClosureControl.CountdownTimeComponent.attributes.countdownTime, { optionalIf: [PS_NOT_IS] }),
+            latchControlModes: MutableCluster.AsConditional(ClosureControl.MotionLatchingComponent.attributes.latchControlModes, { mandatoryIf: [LT] }),
+        },
+        commands: {
+            ...ClosureControl.Base.commands,
+            stop: MutableCluster.AsConditional(ClosureControl.NonInstantaneousComponent.commands.stop, { mandatoryIf: [NOT_IS] }),
+            calibrate: MutableCluster.AsConditional(ClosureControl.CalibrationComponent.commands.calibrate, { mandatoryIf: [CL] }),
+        },
+        events: {
+            ...ClosureControl.Base.events,
+            movementCompleted: MutableCluster.AsConditional(ClosureControl.NonInstantaneousComponent.events.movementCompleted, { mandatoryIf: [NOT_IS] }),
+            engageStateChanged: MutableCluster.AsConditional(ClosureControl.ManuallyOperableComponent.events.engageStateChanged, { mandatoryIf: [MO] }),
+        },
+    });
+})(ClosureControl || (ClosureControl = {}));
+export const ClosureControlCluster = ClosureControl.Cluster;
+ClusterRegistry.register(ClosureControl.Complete);