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

package/dist/devices/closurePanel.d.ts

@@ -0,0 +1,204 @@
+import { MaybePromise } from '@matter/general';
+import { ClusterBehavior } from '@matter/node';
+import { ClosureDimension } from '../clusters/closure-dimension.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export interface ClosurePanelOptions {
+    resolution?: number;
+    stepValue?: number;
+}
+declare const ClosureDimensionServerBase: ClusterBehavior.Type<import("@matter/types").ClusterComposer.Of<import("@matter/types").ClusterType.Of<{
+    readonly id: 261;
+    readonly name: "ClosureDimension";
+    readonly revision: 1;
+    readonly features: {
+        readonly positioning: import("@matter/types").BitFlag;
+        readonly motionLatching: import("@matter/types").BitFlag;
+        readonly unit: import("@matter/types").BitFlag;
+        readonly limitation: import("@matter/types").BitFlag;
+        readonly speed: import("@matter/types").BitFlag;
+        readonly translation: import("@matter/types").BitFlag;
+        readonly rotation: import("@matter/types").BitFlag;
+        readonly modulation: import("@matter/types").BitFlag;
+    };
+    readonly attributes: {
+        readonly currentState: import("@matter/types").Attribute<import("@matter/types").TypeFromFields<{
+            position: import("@matter/types").OptionalFieldType<number | null>;
+            latch: import("@matter/types").OptionalFieldType<boolean | null>;
+            speed: import("@matter/types").OptionalFieldType<import("@matter/types").ThreeLevelAuto>;
+        }> | null, any>;
+        readonly targetState: import("@matter/types").Attribute<import("@matter/types").TypeFromFields<{
+            position: import("@matter/types").OptionalFieldType<number | null>;
+            latch: import("@matter/types").OptionalFieldType<boolean | null>;
+            speed: import("@matter/types").OptionalFieldType<import("@matter/types").ThreeLevelAuto>;
+        }> | null, any>;
+    };
+    readonly commands: {
+        readonly setTarget: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+            position: import("@matter/types").OptionalFieldType<number>;
+            latch: import("@matter/types").OptionalFieldType<boolean>;
+            speed: import("@matter/types").OptionalFieldType<import("@matter/types").ThreeLevelAuto>;
+        }>, void, any>;
+    };
+    readonly extensions: readonly [{
+        readonly flags: {
+            readonly positioning: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly resolution: import("@matter/types").FixedAttribute<number, any>;
+                readonly stepValue: import("@matter/types").FixedAttribute<number, any>;
+            };
+            readonly commands: {
+                readonly step: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+                    direction: import("@matter/types").FieldType<ClosureDimension.StepDirection>;
+                    numberOfSteps: import("@matter/types").FieldType<number>;
+                    speed: import("@matter/types").OptionalFieldType<import("@matter/types").ThreeLevelAuto>;
+                }>, 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 unit: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly unit: import("@matter/types").FixedAttribute<ClosureDimension.ClosureUnit, any>;
+                readonly unitRange: import("@matter/types").Attribute<import("@matter/types").TypeFromFields<{
+                    min: import("@matter/types").FieldType<number>;
+                    max: import("@matter/types").FieldType<number>;
+                }> | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly limitation: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly limitRange: import("@matter/types").Attribute<import("@matter/types").TypeFromFields<{
+                    min: import("@matter/types").FieldType<number>;
+                    max: import("@matter/types").FieldType<number>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly translation: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly translationDirection: import("@matter/types").FixedAttribute<ClosureDimension.TranslationDirection, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly rotation: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly rotationAxis: import("@matter/types").FixedAttribute<ClosureDimension.RotationAxis, any>;
+                readonly overflow: import("@matter/types").FixedAttribute<ClosureDimension.Overflow, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly modulation: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly modulationType: import("@matter/types").FixedAttribute<ClosureDimension.ModulationType, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly positioning: false;
+            readonly motionLatching: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly unit: true;
+            readonly positioning: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly limitation: true;
+            readonly positioning: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly speed: true;
+            readonly positioning: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly translation: true;
+            readonly positioning: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly rotation: true;
+            readonly positioning: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly modulation: true;
+            readonly positioning: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly translation: true;
+            readonly rotation: true;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly translation: true;
+            readonly modulation: true;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly rotation: true;
+            readonly modulation: true;
+        };
+        readonly component: false;
+    }];
+}>, readonly [ClosureDimension.Feature.Positioning]>, typeof ClusterBehavior, {
+    components: never[];
+}>;
+export declare namespace ClosureDimensionServer {
+    interface State {
+        currentState: ClosureDimension.DimensionState | null;
+        targetState: ClosureDimension.DimensionState | null;
+        resolution: number;
+        stepValue: number;
+    }
+}
+export declare class ClosureDimensionServer extends ClosureDimensionServerBase {
+    state: ClosureDimensionServer.State;
+    setTarget: (request: ClosureDimension.SetTargetRequest) => MaybePromise;
+    step: (request: ClosureDimension.StepRequest) => MaybePromise;
+}
+export declare class ClosurePanel extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: ClosurePanelOptions);
+}
+export {};

package/dist/devices/closurePanel.js

@@ -0,0 +1,55 @@
+import { ClusterBehavior } from '@matter/node';
+import { ClosureDimension } from '../clusters/closure-dimension.js';
+import { MatterbridgeServer } from '../matterbridgeBehaviors.js';
+import { closurePanel } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { createClusterSchema } from './customClusterSchema.js';
+const ClosureDimensionCluster = ClosureDimension.Cluster.with(ClosureDimension.Feature.Positioning);
+const ClosureDimensionServerBase = ClusterBehavior.for(ClosureDimensionCluster, createClusterSchema(ClosureDimensionCluster));
+export class ClosureDimensionServer extends ClosureDimensionServerBase {
+    setTarget = (request) => {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`SetTarget (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('setTarget', { request, cluster: ClosureDimension.Cluster.id, attributes: this.state, endpoint: this.endpoint });
+        const previousTarget = this.state.targetState ?? {};
+        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.targetState = nextTarget;
+    };
+    step = (request) => {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Step (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.commandHandler.executeHandler('step', { request, cluster: ClosureDimension.Cluster.id, attributes: this.state, endpoint: this.endpoint });
+        const stepValue = this.state.stepValue;
+        const numberOfSteps = request.numberOfSteps;
+        const delta = stepValue * numberOfSteps;
+        const isIncrease = request.direction === ClosureDimension.StepDirection.Increase;
+        const previousCurrent = this.state.currentState ?? {};
+        const previousTarget = this.state.targetState ?? {};
+        const currentPosition = typeof previousCurrent.position === 'number' ? previousCurrent.position : typeof previousTarget.position === 'number' ? previousTarget.position : 0;
+        let nextPosition = isIncrease ? currentPosition + delta : currentPosition - delta;
+        nextPosition = Math.max(0, Math.min(10000, nextPosition));
+        this.state.currentState = {
+            ...previousCurrent,
+            position: nextPosition,
+            ...(request?.speed !== undefined ? { speed: request.speed } : null),
+        };
+        this.state.targetState = { ...previousTarget, position: nextPosition };
+    };
+}
+export class ClosurePanel extends MatterbridgeEndpoint {
+    constructor(name, serial, options = {}) {
+        super([closurePanel], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Closure Panel');
+        this.behaviors.require(ClosureDimensionServer, {
+            currentState: null,
+            targetState: null,
+            resolution: options.resolution ?? 1,
+            stepValue: options.stepValue ?? 1,
+        });
+    }
+}

package/dist/devices/customClusterSchema.d.ts

@@ -0,0 +1,22 @@
+import { ClusterModel } from '../matter/export.js';
+type AnyCluster = {
+    id: number;
+    name: string;
+    revision?: number;
+    supportedFeatures?: Record<string, boolean>;
+    attributes?: Record<string, {
+        id: number;
+        default?: unknown;
+        optional?: boolean;
+    }>;
+    commands?: Record<string, {
+        requestId: number;
+        optional?: boolean;
+    }>;
+    events?: Record<string, {
+        id: number;
+        optional?: boolean;
+    }>;
+};
+export declare function createClusterSchema(cluster: AnyCluster): ClusterModel;
+export {};

package/dist/devices/customClusterSchema.js

@@ -0,0 +1,53 @@
+import { AttributeElement, ClusterModel, CommandElement, EventElement, FieldElement } from '../matter/export.js';
+export function createClusterSchema(cluster) {
+    const children = [];
+    const featureNames = Object.keys(cluster.supportedFeatures ?? {});
+    if (featureNames.length > 0) {
+        children.push(AttributeElement({
+            id: 0xfffc,
+            name: 'FeatureMap',
+            type: 'FeatureMap',
+            conformance: 'M',
+        }, ...featureNames.map((name, index) => FieldElement({
+            name,
+            id: index,
+            type: 'bool',
+            constraint: index,
+        }))));
+    }
+    for (const [name, attribute] of Object.entries(cluster.attributes ?? {})) {
+        children.push(AttributeElement({
+            id: attribute.id,
+            name,
+            type: 'any',
+            conformance: 'O',
+        }));
+    }
+    for (const [name, command] of Object.entries(cluster.commands ?? {})) {
+        const element = CommandElement({
+            id: command.requestId,
+            name,
+            type: 'any',
+            direction: 'request',
+            conformance: 'O',
+        });
+        element.operationalIsSupported = true;
+        children.push(element);
+    }
+    for (const [name, event] of Object.entries(cluster.events ?? {})) {
+        const element = EventElement({
+            id: event.id,
+            name,
+            type: 'any',
+            priority: name === 'operationalError' ? 'critical' : 'info',
+            conformance: 'O',
+        });
+        element.operationalIsSupported = true;
+        children.push(element);
+    }
+    return new ClusterModel({
+        id: cluster.id,
+        name: cluster.name,
+        revision: cluster.revision ?? 1,
+    }, ...children);
+}

package/dist/devices/export.d.ts

@@ -1,6 +1,10 @@
 export * from './basicVideoPlayer.js';
 export * from './castingVideoPlayer.js';
 export * from './speaker.js';
+export * from './closure.js';
+export * from './closurePanel.js';
+export * from './irrigationSystem.js';
+export * from './soilSensor.js';
 export * from './roboticVacuumCleaner.js';
 export * from './airConditioner.js';
 export * from './cooktop.js';

package/dist/devices/export.js

@@ -1,6 +1,10 @@
 export * from './basicVideoPlayer.js';
 export * from './castingVideoPlayer.js';
 export * from './speaker.js';
+export * from './closure.js';
+export * from './closurePanel.js';
+export * from './irrigationSystem.js';
+export * from './soilSensor.js';
 export * from './roboticVacuumCleaner.js';
 export * from './airConditioner.js';
 export * from './cooktop.js';

package/dist/devices/heatPump.js

@@ -1,11 +1,12 @@
-import { NumberTag, PowerSourceTag } from '@matter/node';
+import { AreaNamespaceTag, NumberTag, PowerSourceTag } from '@matter/node';
 import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
 import { deviceEnergyManagement, electricalSensor, heatPump, powerSource, temperatureSensor, thermostatDevice } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { getSemtag } from '../matterbridgeEndpointHelpers.js';
 export class HeatPump extends MatterbridgeEndpoint {
     constructor(name, serial, voltage = null, current = null, power = null, energyImported = null, absMinPower = 0, absMaxPower = 0) {
         super([heatPump, powerSource, electricalSensor, deviceEnergyManagement], {
-            tagList: [{ mfgCode: null, namespaceId: PowerSourceTag.Grid.namespaceId, tag: PowerSourceTag.Grid.tag, label: null }],
+            tagList: [getSemtag(PowerSourceTag.Grid)],
             id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
         });
         this.createDefaultIdentifyClusterServer()
@@ -18,19 +19,26 @@ export class HeatPump extends MatterbridgeEndpoint {
             .createDefaultDeviceEnergyManagementModeClusterServer()
             .addRequiredClusterServers();
         this.addChildDeviceType('FlowTemperature', temperatureSensor, {
-            tagList: [{ mfgCode: null, namespaceId: NumberTag.One.namespaceId, tag: NumberTag.One.tag, label: 'Flow' }],
+            tagList: [getSemtag(NumberTag.One, 'FlowTemperature')],
         })
             .createDefaultTemperatureMeasurementClusterServer(4500)
             .addRequiredClusterServers();
         this.addChildDeviceType('ReturnTemperature', temperatureSensor, {
-            tagList: [{ mfgCode: null, namespaceId: NumberTag.Two.namespaceId, tag: NumberTag.Two.tag, label: 'Return' }],
+            tagList: [getSemtag(NumberTag.Two, 'ReturnTemperature')],
         })
             .createDefaultTemperatureMeasurementClusterServer(3500)
             .addRequiredClusterServers();
-        this.addChildDeviceType('Thermostat', thermostatDevice, {
-            tagList: [{ mfgCode: null, namespaceId: NumberTag.One.namespaceId, tag: NumberTag.One.tag, label: 'Main Thermostat' }],
+        this.addChildDeviceType('LivingThermostat', thermostatDevice, {
+            tagList: [getSemtag(NumberTag.One, 'LivingThermostat'), getSemtag(AreaNamespaceTag.LivingRoom)],
         })
-            .createDefaultHeatingThermostatClusterServer()
-            .addRequiredClusterServers();
+            .createDefaultThermostatClusterServer()
+            .addRequiredClusterServers()
+            .addUserLabel('room', 'Living Room');
+        this.addChildDeviceType('BedroomThermostat', thermostatDevice, {
+            tagList: [getSemtag(NumberTag.Two, 'BedroomThermostat'), getSemtag(AreaNamespaceTag.Bedroom)],
+        })
+            .createDefaultThermostatClusterServer()
+            .addRequiredClusterServers()
+            .addUserLabel('room', 'Bedroom');
     }
 }

package/dist/devices/irrigationSystem.d.ts

@@ -0,0 +1,9 @@
+import { OperationalState } from '@matter/types/clusters/operational-state';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export interface IrrigationSystemOptions {
+    operationalState?: OperationalState.OperationalStateEnum;
+    flowMeasuredValue?: number | null;
+}
+export declare class IrrigationSystem extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: IrrigationSystemOptions);
+}

package/dist/devices/irrigationSystem.js

@@ -0,0 +1,12 @@
+import { OperationalState } from '@matter/types/clusters/operational-state';
+import { irrigationSystem } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export class IrrigationSystem extends MatterbridgeEndpoint {
+    constructor(name, serial, options = {}) {
+        super([irrigationSystem], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+        this.createDefaultIdentifyClusterServer();
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Irrigation System');
+        this.createDefaultOperationalStateClusterServer(options.operationalState ?? OperationalState.OperationalStateEnum.Stopped);
+        this.createDefaultFlowMeasurementClusterServer(options.flowMeasuredValue ?? null);
+    }
+}

package/dist/devices/soilSensor.d.ts

@@ -0,0 +1,14 @@
+import { ClusterBehavior } from '@matter/node';
+import { SoilMeasurement } from '../clusters/soil-measurement.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export interface SoilSensorOptions {
+    soilMoistureMeasuredValue?: number | null;
+}
+export declare const SoilMeasurementServer: ClusterBehavior.Type<SoilMeasurement.Cluster, typeof ClusterBehavior, {
+    components: never[];
+}>;
+export declare class SoilSensor extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: SoilSensorOptions);
+    setSoilMoistureMeasuredValue(value: number | null): Promise<void>;
+    getSoilMoistureMeasuredValue(): number | null;
+}

package/dist/devices/soilSensor.js

@@ -0,0 +1,30 @@
+import { ClusterBehavior } from '@matter/node';
+import { MeasurementType } from '@matter/types/globals';
+import { SoilMeasurement } from '../clusters/soil-measurement.js';
+import { soilSensor } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { createClusterSchema } from './customClusterSchema.js';
+export const SoilMeasurementServer = ClusterBehavior.for(SoilMeasurement.Cluster, createClusterSchema(SoilMeasurement.Cluster));
+export class SoilSensor extends MatterbridgeEndpoint {
+    constructor(name, serial, options = {}) {
+        super([soilSensor], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` });
+        this.createDefaultIdentifyClusterServer();
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Soil Sensor');
+        this.behaviors.require(SoilMeasurementServer, {
+            soilMoistureMeasurementLimits: {
+                measurementType: MeasurementType.SoilMoisture,
+                measured: true,
+                minMeasuredValue: 0,
+                maxMeasuredValue: 100,
+                accuracyRanges: [{ rangeMin: 0, rangeMax: 100, fixedMax: 1 }],
+            },
+            soilMoistureMeasuredValue: options.soilMoistureMeasuredValue ?? null,
+        });
+    }
+    async setSoilMoistureMeasuredValue(value) {
+        await this.setAttribute(SoilMeasurement.Cluster.id, 'soilMoistureMeasuredValue', value);
+    }
+    getSoilMoistureMeasuredValue() {
+        return this.getAttribute(SoilMeasurement.Cluster.id, 'soilMoistureMeasuredValue');
+    }
+}

package/dist/devices/solarPower.d.ts

@@ -1,4 +1,6 @@
+import { Semtag } from '@matter/types/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export declare class SolarPower extends MatterbridgeEndpoint {
-    constructor(name: string, serial: string, voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, energyExported?: number | bigint | null, absMinPower?: number, absMaxPower?: number);
+    constructor(name: string, serial: string, voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, energyExported?: number | bigint, absMinPower?: number, absMaxPower?: number);
+    addPanel(name: string, tag: Semtag, voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, energyExported?: number | bigint | null): MatterbridgeEndpoint;
 }

package/dist/devices/solarPower.js

@@ -2,11 +2,12 @@ import { PowerSourceTag } from '@matter/node';
 import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
 import { deviceEnergyManagement, electricalSensor, powerSource, solarPower } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { getSemtag } from '../matterbridgeEndpointHelpers.js';
 export class SolarPower extends MatterbridgeEndpoint {
-    constructor(name, serial, voltage = null, current = null, power = null, energyExported = null, absMinPower = 0, absMaxPower = 0) {
+    constructor(name, serial, voltage = null, current = null, power = null, energyExported = 0, absMinPower = 0, absMaxPower = 0) {
         super([solarPower, powerSource, electricalSensor, deviceEnergyManagement], {
-            tagList: [{ mfgCode: null, namespaceId: PowerSourceTag.Solar.namespaceId, tag: PowerSourceTag.Solar.tag, label: null }],
             id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            tagList: [getSemtag(PowerSourceTag.Solar)],
         });
         this.createDefaultIdentifyClusterServer()
             .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Solar Power')
@@ -18,4 +19,15 @@ export class SolarPower extends MatterbridgeEndpoint {
             .createDefaultDeviceEnergyManagementModeClusterServer()
             .addRequiredClusterServers();
     }
+    addPanel(name, tag, voltage = null, current = null, power = null, energyExported = null) {
+        const panel = this.addChildDeviceType(name, electricalSensor, {
+            tagList: [getSemtag(PowerSourceTag.Solar), getSemtag(tag)],
+        })
+            .createDefaultPowerTopologyClusterServer()
+            .createDefaultElectricalPowerMeasurementClusterServer(voltage, current, power)
+            .createDefaultElectricalEnergyMeasurementClusterServer(0, energyExported)
+            .addRequiredClusterServers();
+        panel.addUserLabel('panel', name.slice(0, 16));
+        return panel;
+    }
 }