@matterbridge/core 3.6.0-dev-20260302-e3a7eb0 → 3.6.0-dev-20260303-2f99eca

package/dist/clusters/closure-dimension.js

@@ -0,0 +1,202 @@
+import { Attribute, ClusterRegistry, Command, FixedAttribute, MutableCluster, TlvNoResponse } from '@matter/types/cluster';
+import { BitFlag } from '@matter/types/schema';
+import { TlvBitmap, TlvBoolean, TlvEnum, TlvField, TlvInt16, TlvNullable, TlvObject, TlvOptionalField, TlvPercent100ths, TlvUInt8, TlvUInt16, } from '@matter/types/tlv';
+export var ClosureDimension;
+(function (ClosureDimension) {
+    let Feature;
+    (function (Feature) {
+        Feature["Positioning"] = "Positioning";
+        Feature["MotionLatching"] = "MotionLatching";
+        Feature["Unit"] = "Unit";
+        Feature["Limitation"] = "Limitation";
+        Feature["Speed"] = "Speed";
+        Feature["Translation"] = "Translation";
+        Feature["Rotation"] = "Rotation";
+        Feature["Modulation"] = "Modulation";
+    })(Feature = ClosureDimension.Feature || (ClosureDimension.Feature = {}));
+    let ClosureUnit;
+    (function (ClosureUnit) {
+        ClosureUnit[ClosureUnit["Millimeter"] = 0] = "Millimeter";
+        ClosureUnit[ClosureUnit["Degree"] = 1] = "Degree";
+    })(ClosureUnit = ClosureDimension.ClosureUnit || (ClosureDimension.ClosureUnit = {}));
+    let ModulationType;
+    (function (ModulationType) {
+        ModulationType[ModulationType["SlatsOrientation"] = 0] = "SlatsOrientation";
+        ModulationType[ModulationType["SlatsOpenwork"] = 1] = "SlatsOpenwork";
+        ModulationType[ModulationType["StripesAlignment"] = 2] = "StripesAlignment";
+        ModulationType[ModulationType["Opacity"] = 3] = "Opacity";
+        ModulationType[ModulationType["Ventilation"] = 4] = "Ventilation";
+    })(ModulationType = ClosureDimension.ModulationType || (ClosureDimension.ModulationType = {}));
+    let Overflow;
+    (function (Overflow) {
+        Overflow[Overflow["NoOverflow"] = 0] = "NoOverflow";
+        Overflow[Overflow["Inside"] = 1] = "Inside";
+        Overflow[Overflow["Outside"] = 2] = "Outside";
+        Overflow[Overflow["TopInside"] = 3] = "TopInside";
+        Overflow[Overflow["TopOutside"] = 4] = "TopOutside";
+        Overflow[Overflow["BottomInside"] = 5] = "BottomInside";
+        Overflow[Overflow["BottomOutside"] = 6] = "BottomOutside";
+        Overflow[Overflow["LeftInside"] = 7] = "LeftInside";
+        Overflow[Overflow["LeftOutside"] = 8] = "LeftOutside";
+        Overflow[Overflow["RightInside"] = 9] = "RightInside";
+        Overflow[Overflow["RightOutside"] = 10] = "RightOutside";
+    })(Overflow = ClosureDimension.Overflow || (ClosureDimension.Overflow = {}));
+    let RotationAxis;
+    (function (RotationAxis) {
+        RotationAxis[RotationAxis["Left"] = 0] = "Left";
+        RotationAxis[RotationAxis["CenteredVertical"] = 1] = "CenteredVertical";
+        RotationAxis[RotationAxis["LeftAndRight"] = 2] = "LeftAndRight";
+        RotationAxis[RotationAxis["Right"] = 3] = "Right";
+        RotationAxis[RotationAxis["Top"] = 4] = "Top";
+        RotationAxis[RotationAxis["CenteredHorizontal"] = 5] = "CenteredHorizontal";
+        RotationAxis[RotationAxis["TopAndBottom"] = 6] = "TopAndBottom";
+        RotationAxis[RotationAxis["Bottom"] = 7] = "Bottom";
+        RotationAxis[RotationAxis["LeftBarrier"] = 8] = "LeftBarrier";
+        RotationAxis[RotationAxis["LeftAndRightBarriers"] = 9] = "LeftAndRightBarriers";
+        RotationAxis[RotationAxis["RightBarrier"] = 10] = "RightBarrier";
+    })(RotationAxis = ClosureDimension.RotationAxis || (ClosureDimension.RotationAxis = {}));
+    let StepDirection;
+    (function (StepDirection) {
+        StepDirection[StepDirection["Decrease"] = 0] = "Decrease";
+        StepDirection[StepDirection["Increase"] = 1] = "Increase";
+    })(StepDirection = ClosureDimension.StepDirection || (ClosureDimension.StepDirection = {}));
+    let TranslationDirection;
+    (function (TranslationDirection) {
+        TranslationDirection[TranslationDirection["Downward"] = 0] = "Downward";
+        TranslationDirection[TranslationDirection["Upward"] = 1] = "Upward";
+        TranslationDirection[TranslationDirection["VerticalMask"] = 2] = "VerticalMask";
+        TranslationDirection[TranslationDirection["VerticalSymmetry"] = 3] = "VerticalSymmetry";
+        TranslationDirection[TranslationDirection["Leftward"] = 4] = "Leftward";
+        TranslationDirection[TranslationDirection["Rightward"] = 5] = "Rightward";
+        TranslationDirection[TranslationDirection["HorizontalMask"] = 6] = "HorizontalMask";
+        TranslationDirection[TranslationDirection["HorizontalSymmetry"] = 7] = "HorizontalSymmetry";
+        TranslationDirection[TranslationDirection["Forward"] = 8] = "Forward";
+        TranslationDirection[TranslationDirection["Backward"] = 9] = "Backward";
+        TranslationDirection[TranslationDirection["DepthMask"] = 10] = "DepthMask";
+        TranslationDirection[TranslationDirection["DepthSymmetry"] = 11] = "DepthSymmetry";
+    })(TranslationDirection = ClosureDimension.TranslationDirection || (ClosureDimension.TranslationDirection = {}));
+    ClosureDimension.LatchControlModes = {
+        remoteLatching: BitFlag(0),
+        remoteUnlatching: BitFlag(1),
+    };
+    ClosureDimension.TlvDimensionState = TlvObject({
+        position: TlvOptionalField(0, TlvNullable(TlvPercent100ths)),
+        latch: TlvOptionalField(1, TlvNullable(TlvBoolean)),
+        speed: TlvOptionalField(2, TlvEnum()),
+    });
+    ClosureDimension.TlvRangePercent100ths = TlvObject({
+        min: TlvField(0, TlvPercent100ths),
+        max: TlvField(1, TlvPercent100ths),
+    });
+    ClosureDimension.TlvUnitRange = TlvObject({
+        min: TlvField(0, TlvInt16),
+        max: TlvField(1, TlvInt16),
+    });
+    ClosureDimension.TlvSetTargetRequest = TlvObject({
+        position: TlvOptionalField(0, TlvPercent100ths),
+        latch: TlvOptionalField(1, TlvBoolean),
+        speed: TlvOptionalField(2, TlvEnum()),
+    });
+    ClosureDimension.TlvStepRequest = TlvObject({
+        direction: TlvField(0, TlvEnum()),
+        numberOfSteps: TlvField(1, TlvUInt16.bound({ min: 1 })),
+        speed: TlvOptionalField(2, TlvEnum()),
+    });
+    ClosureDimension.PositioningComponent = MutableCluster.Component({
+        attributes: {
+            resolution: FixedAttribute(0x2, TlvPercent100ths, { default: 1 }),
+            stepValue: FixedAttribute(0x3, TlvPercent100ths, { default: 1 }),
+        },
+        commands: {
+            step: Command(0x1, ClosureDimension.TlvStepRequest, 0x1, TlvNoResponse, { timed: true }),
+        },
+    });
+    ClosureDimension.MotionLatchingComponent = MutableCluster.Component({
+        attributes: {
+            latchControlModes: FixedAttribute(0xb, TlvBitmap(TlvUInt8, ClosureDimension.LatchControlModes)),
+        },
+    });
+    ClosureDimension.UnitComponent = MutableCluster.Component({
+        attributes: {
+            unit: FixedAttribute(0x4, TlvEnum()),
+            unitRange: Attribute(0x5, TlvNullable(ClosureDimension.TlvUnitRange), { default: null }),
+        },
+    });
+    ClosureDimension.LimitationComponent = MutableCluster.Component({
+        attributes: {
+            limitRange: Attribute(0x6, ClosureDimension.TlvRangePercent100ths),
+        },
+    });
+    ClosureDimension.TranslationComponent = MutableCluster.Component({
+        attributes: {
+            translationDirection: FixedAttribute(0x7, TlvEnum()),
+        },
+    });
+    ClosureDimension.RotationComponent = MutableCluster.Component({
+        attributes: {
+            rotationAxis: FixedAttribute(0x8, TlvEnum()),
+            overflow: FixedAttribute(0x9, TlvEnum()),
+        },
+    });
+    ClosureDimension.ModulationComponent = MutableCluster.Component({
+        attributes: {
+            modulationType: FixedAttribute(0xa, TlvEnum()),
+        },
+    });
+    ClosureDimension.Base = MutableCluster.Component({
+        id: 0x0105,
+        name: 'ClosureDimension',
+        revision: 1,
+        features: {
+            positioning: BitFlag(0),
+            motionLatching: BitFlag(1),
+            unit: BitFlag(2),
+            limitation: BitFlag(3),
+            speed: BitFlag(4),
+            translation: BitFlag(5),
+            rotation: BitFlag(6),
+            modulation: BitFlag(7),
+        },
+        attributes: {
+            currentState: Attribute(0x0, TlvNullable(ClosureDimension.TlvDimensionState), { default: null }),
+            targetState: Attribute(0x1, TlvNullable(ClosureDimension.TlvDimensionState), { default: null }),
+        },
+        commands: {
+            setTarget: Command(0x0, ClosureDimension.TlvSetTargetRequest, 0x0, TlvNoResponse, { timed: true }),
+        },
+        extensions: MutableCluster.Extensions({ flags: { positioning: true }, component: ClosureDimension.PositioningComponent }, { flags: { motionLatching: true }, component: ClosureDimension.MotionLatchingComponent }, { flags: { unit: true }, component: ClosureDimension.UnitComponent }, { flags: { limitation: true }, component: ClosureDimension.LimitationComponent }, { flags: { translation: true }, component: ClosureDimension.TranslationComponent }, { flags: { rotation: true }, component: ClosureDimension.RotationComponent }, { flags: { modulation: true }, component: ClosureDimension.ModulationComponent }, { flags: { positioning: false, motionLatching: false }, component: false }, { flags: { unit: true, positioning: false }, component: false }, { flags: { limitation: true, positioning: false }, component: false }, { flags: { speed: true, positioning: false }, component: false }, { flags: { translation: true, positioning: false }, component: false }, { flags: { rotation: true, positioning: false }, component: false }, { flags: { modulation: true, positioning: false }, component: false }, { flags: { translation: true, rotation: true }, component: false }, { flags: { translation: true, modulation: true }, component: false }, { flags: { rotation: true, modulation: true }, component: false }),
+    });
+    ClosureDimension.Cluster = MutableCluster.ExtensibleOnly(ClosureDimension.Base);
+    const PS = { positioning: true };
+    const LT = { motionLatching: true };
+    const UT = { unit: true };
+    const LM = { limitation: true };
+    const TR = { translation: true };
+    const RO = { rotation: true };
+    const MD = { modulation: true };
+    ClosureDimension.Complete = MutableCluster({
+        id: ClosureDimension.Base.id,
+        name: ClosureDimension.Base.name,
+        revision: ClosureDimension.Base.revision,
+        features: ClosureDimension.Base.features,
+        attributes: {
+            ...ClosureDimension.Base.attributes,
+            resolution: MutableCluster.AsConditional(ClosureDimension.PositioningComponent.attributes.resolution, { mandatoryIf: [PS] }),
+            stepValue: MutableCluster.AsConditional(ClosureDimension.PositioningComponent.attributes.stepValue, { mandatoryIf: [PS] }),
+            unit: MutableCluster.AsConditional(ClosureDimension.UnitComponent.attributes.unit, { mandatoryIf: [UT] }),
+            unitRange: MutableCluster.AsConditional(ClosureDimension.UnitComponent.attributes.unitRange, { mandatoryIf: [UT] }),
+            limitRange: MutableCluster.AsConditional(ClosureDimension.LimitationComponent.attributes.limitRange, { mandatoryIf: [LM] }),
+            translationDirection: MutableCluster.AsConditional(ClosureDimension.TranslationComponent.attributes.translationDirection, { mandatoryIf: [TR] }),
+            rotationAxis: MutableCluster.AsConditional(ClosureDimension.RotationComponent.attributes.rotationAxis, { mandatoryIf: [RO] }),
+            overflow: MutableCluster.AsConditional(ClosureDimension.RotationComponent.attributes.overflow, { mandatoryIf: [RO] }),
+            modulationType: MutableCluster.AsConditional(ClosureDimension.ModulationComponent.attributes.modulationType, { mandatoryIf: [MD] }),
+            latchControlModes: MutableCluster.AsConditional(ClosureDimension.MotionLatchingComponent.attributes.latchControlModes, { mandatoryIf: [LT] }),
+        },
+        commands: {
+            ...ClosureDimension.Base.commands,
+            step: MutableCluster.AsConditional(ClosureDimension.PositioningComponent.commands.step, { mandatoryIf: [PS] }),
+        },
+    });
+})(ClosureDimension || (ClosureDimension = {}));
+export const ClosureDimensionCluster = ClosureDimension.Cluster;
+ClusterRegistry.register(ClosureDimension.Complete);

package/dist/clusters/export.d.ts

@@ -1 +1,3 @@
-export {};
+export * from './closure-control.js';
+export * from './closure-dimension.js';
+export * from './soil-measurement.js';

package/dist/clusters/export.js

@@ -1 +1,3 @@
-export {};
+export * from './closure-control.js';
+export * from './closure-dimension.js';
+export * from './soil-measurement.js';

package/dist/clusters/soil-measurement.d.ts

@@ -0,0 +1,34 @@
+import { Identity } from '@matter/general';
+import { Attribute, FixedAttribute, MutableCluster } from '@matter/types/cluster';
+export declare namespace SoilMeasurement {
+    const ClusterInstance: MutableCluster<{
+        readonly id: 1072;
+        readonly name: "SoilMeasurement";
+        readonly revision: 1;
+        readonly attributes: {
+            readonly soilMoistureMeasurementLimits: FixedAttribute<import("@matter/types/tlv").TypeFromFields<{
+                measurementType: import("@matter/types/tlv").FieldType<import("@matter/types/globals").MeasurementType>;
+                measured: import("@matter/types/tlv").FieldType<boolean>;
+                minMeasuredValue: import("@matter/types/tlv").FieldType<number | bigint>;
+                maxMeasuredValue: import("@matter/types/tlv").FieldType<number | bigint>;
+                accuracyRanges: import("@matter/types/tlv").FieldType<import("@matter/types/tlv").TypeFromFields<{
+                    rangeMin: import("@matter/types/tlv").FieldType<number | bigint>;
+                    rangeMax: import("@matter/types/tlv").FieldType<number | bigint>;
+                    percentMax: import("@matter/types/tlv").OptionalFieldType<number>;
+                    percentMin: import("@matter/types/tlv").OptionalFieldType<number>;
+                    percentTypical: import("@matter/types/tlv").OptionalFieldType<number>;
+                    fixedMax: import("@matter/types/tlv").OptionalFieldType<number | bigint>;
+                    fixedMin: import("@matter/types/tlv").OptionalFieldType<number | bigint>;
+                    fixedTypical: import("@matter/types/tlv").OptionalFieldType<number | bigint>;
+                }>[]>;
+            }>, any>;
+            readonly soilMoistureMeasuredValue: Attribute<number | null, any>;
+        };
+    }, []>;
+    interface Cluster extends Identity<typeof ClusterInstance> {
+    }
+    const Cluster: Cluster;
+    const Complete: Cluster;
+}
+export type SoilMeasurementCluster = SoilMeasurement.Cluster;
+export declare const SoilMeasurementCluster: SoilMeasurement.Cluster;

package/dist/clusters/soil-measurement.js

@@ -0,0 +1,19 @@
+import { Attribute, ClusterRegistry, FixedAttribute, MutableCluster } from '@matter/types/cluster';
+import { TlvMeasurementAccuracy } from '@matter/types/globals';
+import { TlvNullable, TlvPercent } from '@matter/types/tlv';
+export var SoilMeasurement;
+(function (SoilMeasurement) {
+    SoilMeasurement.ClusterInstance = MutableCluster({
+        id: 0x0430,
+        name: 'SoilMeasurement',
+        revision: 1,
+        attributes: {
+            soilMoistureMeasurementLimits: FixedAttribute(0x0, TlvMeasurementAccuracy),
+            soilMoistureMeasuredValue: Attribute(0x1, TlvNullable(TlvPercent)),
+        },
+    });
+    SoilMeasurement.Cluster = SoilMeasurement.ClusterInstance;
+    SoilMeasurement.Complete = SoilMeasurement.Cluster;
+})(SoilMeasurement || (SoilMeasurement = {}));
+export const SoilMeasurementCluster = SoilMeasurement.Cluster;
+ClusterRegistry.register(SoilMeasurement.Complete);

package/dist/devices/batteryStorage.js

@@ -1,28 +1,33 @@
+import { ElectricalPowerMeasurementServer } from '@matter/main/behaviors/electrical-power-measurement';
+import { ElectricalPowerMeasurement } from '@matter/main/clusters/electrical-power-measurement';
 import { PowerSourceTag } from '@matter/node';
 import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
 import { PowerSource } from '@matter/types/clusters/power-source';
 import { batteryStorage, deviceEnergyManagement, electricalSensor, powerSource } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { getDefaultElectricalPowerMeasurementClusterServer, getSemtag } from '../matterbridgeEndpointHelpers.js';
 export class BatteryStorage extends MatterbridgeEndpoint {
     constructor(name, serial, batPercentRemaining = 100, batChargeLevel = PowerSource.BatChargeLevel.Ok, voltage = null, current = null, power = null, energyImported = null, energyExported = null, absMinPower = 0, absMaxPower = 0) {
-        super([batteryStorage, electricalSensor, deviceEnergyManagement], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+        super([batteryStorage, powerSource, electricalSensor, deviceEnergyManagement], {
+            id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            tagList: [getSemtag(PowerSourceTag.Grid)],
+        });
         this.createDefaultIdentifyClusterServer()
-            .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Solar Power')
+            .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Battery Storage')
+            .createDefaultPowerSourceWiredClusterServer()
             .createDefaultPowerTopologyClusterServer()
             .createDefaultElectricalPowerMeasurementClusterServer(voltage, current, power)
             .createDefaultElectricalEnergyMeasurementClusterServer(energyImported, energyExported)
             .createDefaultDeviceEnergyManagementClusterServer(DeviceEnergyManagement.EsaType.BatteryStorage, true, DeviceEnergyManagement.EsaState.Online, absMinPower, absMaxPower)
             .createDefaultDeviceEnergyManagementModeClusterServer()
             .addRequiredClusterServers();
-        this.addChildDeviceType('BatteryPowerSource', powerSource, {
-            tagList: [{ mfgCode: null, namespaceId: PowerSourceTag.Battery.namespaceId, tag: PowerSourceTag.Battery.tag, label: null }],
+        this.addFixedLabel('composed', 'Battery Storage');
+        const battery = this.addChildDeviceType('Battery', [powerSource, electricalSensor], {
+            tagList: [getSemtag(PowerSourceTag.Battery)],
         })
             .createDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining, batChargeLevel, 24_000)
-            .addRequiredClusterServers();
-        this.addChildDeviceType('GridPowerSource', powerSource, {
-            tagList: [{ mfgCode: null, namespaceId: PowerSourceTag.Grid.namespaceId, tag: PowerSourceTag.Grid.tag, label: null }],
-        })
-            .createDefaultPowerSourceWiredClusterServer()
-            .addRequiredClusterServers();
+            .createDefaultPowerTopologyClusterServer()
+            .createDefaultElectricalEnergyMeasurementClusterServer(energyImported, energyExported);
+        battery.behaviors.require(ElectricalPowerMeasurementServer.with(ElectricalPowerMeasurement.Feature.DirectCurrent), getDefaultElectricalPowerMeasurementClusterServer(voltage, current, power));
     }
 }

package/dist/devices/closure.d.ts

@@ -0,0 +1,165 @@
+import { MaybePromise } from '@matter/general';
+import { ClusterBehavior } from '@matter/node';
+import { ClosureControl } from '../clusters/closure-control.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export interface ClosureOptions {
+    mainState?: ClosureControl.MainState;
+}
+declare const ClosureControlServerBase: ClusterBehavior.Type<import("@matter/types").ClusterComposer.Of<import("@matter/types").ClusterType.Of<{
+    readonly id: 260;
+    readonly name: "ClosureControl";
+    readonly revision: 1;
+    readonly features: {
+        readonly positioning: import("@matter/types").BitFlag;
+        readonly motionLatching: import("@matter/types").BitFlag;
+        readonly instantaneous: import("@matter/types").BitFlag;
+        readonly speed: import("@matter/types").BitFlag;
+        readonly ventilation: import("@matter/types").BitFlag;
+        readonly pedestrian: import("@matter/types").BitFlag;
+        readonly calibration: import("@matter/types").BitFlag;
+        readonly protection: import("@matter/types").BitFlag;
+        readonly manuallyOperable: import("@matter/types").BitFlag;
+    };
+    readonly attributes: {
+        readonly mainState: import("@matter/types").Attribute<ClosureControl.MainState, any>;
+        readonly currentErrorList: import("@matter/types").Attribute<ClosureControl.ClosureError[], any>;
+        readonly overallCurrentState: import("@matter/types").Attribute<import("@matter/types").TypeFromFields<{
+            position: import("@matter/types").OptionalFieldType<ClosureControl.CurrentPosition | null>;
+            latch: import("@matter/types").OptionalFieldType<boolean | null>;
+            speed: import("@matter/types").OptionalFieldType<import("@matter/types").ThreeLevelAuto>;
+            secureState: import("@matter/types").OptionalFieldType<boolean | null>;
+        }> | null, any>;
+        readonly overallTargetState: import("@matter/types").Attribute<import("@matter/types").TypeFromFields<{
+            position: import("@matter/types").OptionalFieldType<ClosureControl.TargetPosition | null>;
+            latch: import("@matter/types").OptionalFieldType<boolean | null>;
+            speed: import("@matter/types").OptionalFieldType<import("@matter/types").ThreeLevelAuto>;
+        }> | null, any>;
+    };
+    readonly commands: {
+        readonly moveTo: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+            position: import("@matter/types").OptionalFieldType<ClosureControl.TargetPosition>;
+            latch: import("@matter/types").OptionalFieldType<boolean>;
+            speed: import("@matter/types").OptionalFieldType<import("@matter/types").ThreeLevelAuto>;
+        }>, void, any>;
+    };
+    readonly events: {
+        readonly operationalError: import("@matter/types").Event<import("@matter/types").TypeFromFields<{
+            errorState: import("@matter/types").FieldType<ClosureControl.ClosureError[]>;
+        }>, any>;
+        readonly secureStateChanged: import("@matter/types").Event<import("@matter/types").TypeFromFields<{
+            secureValue: import("@matter/types").FieldType<boolean>;
+        }>, any>;
+    };
+    readonly extensions: readonly [{
+        readonly flags: {
+            readonly instantaneous: false;
+        };
+        readonly component: {
+            readonly commands: {
+                readonly stop: import("@matter/types").Command<void, void, any>;
+            };
+            readonly events: {
+                readonly movementCompleted: import("@matter/types").Event<void, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly motionLatching: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly latchControlModes: import("@matter/types").FixedAttribute<import("@matter/types").TypeFromPartialBitSchema<{
+                    remoteLatching: import("@matter/types").BitFlag;
+                    remoteUnlatching: import("@matter/types").BitFlag;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly calibration: true;
+        };
+        readonly component: {
+            readonly commands: {
+                readonly calibrate: import("@matter/types").Command<void, void, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly manuallyOperable: true;
+        };
+        readonly component: {
+            readonly events: {
+                readonly engageStateChanged: import("@matter/types").Event<import("@matter/types").TypeFromFields<{
+                    engageValue: import("@matter/types").FieldType<boolean>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly positioning: true;
+            readonly instantaneous: false;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly countdownTime: import("@matter/types").Attribute<number | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly positioning: false;
+            readonly motionLatching: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly speed: true;
+            readonly positioning: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly speed: true;
+            readonly instantaneous: true;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly ventilation: true;
+            readonly positioning: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly pedestrian: true;
+            readonly positioning: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly calibration: true;
+            readonly positioning: false;
+        };
+        readonly component: false;
+    }];
+}>, readonly [ClosureControl.Feature.Positioning]>, typeof ClusterBehavior, {
+    components: never[];
+}>;
+export declare namespace ClosureControlServer {
+    interface State {
+        mainState: ClosureControl.MainState;
+        currentErrorList: ClosureControl.ClosureError[];
+        overallCurrentState: ClosureControl.OverallCurrentState | null;
+        overallTargetState: ClosureControl.OverallTargetState | null;
+        countdownTime: number | null;
+    }
+}
+export declare class ClosureControlServer extends ClosureControlServerBase {
+    state: ClosureControlServer.State;
+    moveTo: (request: ClosureControl.MoveToRequest) => MaybePromise;
+    stop: () => MaybePromise;
+}
+export declare class Closure extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: ClosureOptions);
+    getMainState(): ClosureControl.MainState;
+}
+export {};

package/dist/devices/closure.js

@@ -0,0 +1,47 @@
+import { ClusterBehavior } from '@matter/node';
+import { ClosureControl } from '../clusters/closure-control.js';
+import { MatterbridgeServer } from '../matterbridgeBehaviors.js';
+import { closure } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { createClusterSchema } from './customClusterSchema.js';
+const ClosureControlCluster = ClosureControl.Cluster.with(ClosureControl.Feature.Positioning);
+const ClosureControlServerBase = ClusterBehavior.for(ClosureControlCluster, createClusterSchema(ClosureControlCluster));
+export class ClosureControlServer extends ClosureControlServerBase {
+    moveTo = (request) => {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`MoveTo (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('moveTo', { request, cluster: ClosureControl.Cluster.id, attributes: this.state, endpoint: this.endpoint });
+        const previousTarget = this.state.overallTargetState ?? {};
+        const nextTarget = {
+            ...previousTarget,
+            ...(request?.position !== undefined ? { position: request.position } : null),
+            ...(request?.latch !== undefined ? { latch: request.latch } : null),
+            ...(request?.speed !== undefined ? { speed: request.speed } : null),
+        };
+        this.state.overallTargetState = nextTarget;
+        this.state.mainState = ClosureControl.MainState.Moving;
+    };
+    stop = () => {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Stop (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('stop', { request: {}, cluster: ClosureControl.Cluster.id, attributes: this.state, endpoint: this.endpoint });
+        this.state.mainState = ClosureControl.MainState.Stopped;
+    };
+}
+export class Closure extends MatterbridgeEndpoint {
+    constructor(name, serial, options = {}) {
+        super([closure], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+        this.createDefaultIdentifyClusterServer();
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Closure');
+        this.behaviors.require(ClosureControlServer, {
+            mainState: options.mainState ?? ClosureControl.MainState.Stopped,
+            currentErrorList: [],
+            overallCurrentState: null,
+            overallTargetState: null,
+            countdownTime: null,
+        });
+    }
+    getMainState() {
+        return this.getAttribute(ClosureControl.Cluster.id, 'mainState');
+    }
+}