matterbridge 3.4.7-dev-20260104-6b10cee → 3.4.7-dev-20260112-a00b2bf

package/dist/matterbridgeDeviceTypes.d.ts

@@ -0,0 +1,95 @@
+import { ClusterId, DeviceTypeId } from '@matter/types/datatype';
+export declare enum DeviceClasses {
+    Node = "Node",
+    App = "App",
+    Utility = "Utility",
+    Simple = "Simple",
+    Dynamic = "Dynamic",
+    Composed = "Composed",
+    Client = "Client",
+    Server = "Server",
+    Duplicate = "Duplicate",
+    BridgedPowerSourceInfo = "BridgedPowerSourceInfo"
+}
+export interface DeviceTypeDefinition {
+    name: string;
+    code: DeviceTypeId;
+    deviceClass: DeviceClasses;
+    revision: number;
+    requiredServerClusters: ClusterId[];
+    optionalServerClusters: ClusterId[];
+    requiredClientClusters: ClusterId[];
+    optionalClientClusters: ClusterId[];
+}
+export declare const DeviceTypeDefinition: ({ name, code, deviceClass, revision, requiredServerClusters, optionalServerClusters, requiredClientClusters, optionalClientClusters, }: {
+    name: string;
+    code: number;
+    deviceClass: DeviceClasses;
+    revision: number;
+    requiredServerClusters?: ClusterId[];
+    optionalServerClusters?: ClusterId[];
+    requiredClientClusters?: ClusterId[];
+    optionalClientClusters?: ClusterId[];
+}) => DeviceTypeDefinition;
+export declare const rootNode: DeviceTypeDefinition;
+export declare const powerSource: DeviceTypeDefinition;
+export declare const OTARequestor: DeviceTypeDefinition;
+export declare const OTAProvider: DeviceTypeDefinition;
+export declare const bridgedNode: DeviceTypeDefinition;
+export declare const electricalSensor: DeviceTypeDefinition;
+export declare const deviceEnergyManagement: DeviceTypeDefinition;
+export declare const onOffLight: DeviceTypeDefinition;
+export declare const dimmableLight: DeviceTypeDefinition;
+export declare const colorTemperatureLight: DeviceTypeDefinition;
+export declare const extendedColorLight: DeviceTypeDefinition;
+export declare const onOffOutlet: DeviceTypeDefinition;
+export declare const dimmableOutlet: DeviceTypeDefinition;
+export declare const onOffMountedSwitch: DeviceTypeDefinition;
+export declare const dimmableMountedSwitch: DeviceTypeDefinition;
+export declare const pumpDevice: DeviceTypeDefinition;
+export declare const waterValve: DeviceTypeDefinition;
+export declare const onOffSwitch: DeviceTypeDefinition;
+export declare const dimmableSwitch: DeviceTypeDefinition;
+export declare const colorTemperatureSwitch: DeviceTypeDefinition;
+export declare const genericSwitch: DeviceTypeDefinition;
+export declare const contactSensor: DeviceTypeDefinition;
+export declare const lightSensor: DeviceTypeDefinition;
+export declare const occupancySensor: DeviceTypeDefinition;
+export declare const temperatureSensor: DeviceTypeDefinition;
+export declare const pressureSensor: DeviceTypeDefinition;
+export declare const flowSensor: DeviceTypeDefinition;
+export declare const humiditySensor: DeviceTypeDefinition;
+export declare const smokeCoAlarm: DeviceTypeDefinition;
+export declare const airQualitySensor: DeviceTypeDefinition;
+export declare const waterFreezeDetector: DeviceTypeDefinition;
+export declare const waterLeakDetector: DeviceTypeDefinition;
+export declare const rainSensor: DeviceTypeDefinition;
+export declare const doorLockDevice: DeviceTypeDefinition;
+export declare const coverDevice: DeviceTypeDefinition;
+export declare const thermostatDevice: DeviceTypeDefinition;
+export declare const fanDevice: DeviceTypeDefinition;
+export declare const airPurifier: DeviceTypeDefinition;
+export declare const basicVideoPlayer: DeviceTypeDefinition;
+export declare const castingVideoPlayer: DeviceTypeDefinition;
+export declare const speakerDevice: DeviceTypeDefinition;
+export declare const modeSelect: DeviceTypeDefinition;
+export declare const aggregator: DeviceTypeDefinition;
+export declare const bridge: DeviceTypeDefinition;
+export declare const roboticVacuumCleaner: DeviceTypeDefinition;
+export declare const laundryWasher: DeviceTypeDefinition;
+export declare const refrigerator: DeviceTypeDefinition;
+export declare const airConditioner: DeviceTypeDefinition;
+export declare const temperatureControlledCabinetCooler: DeviceTypeDefinition;
+export declare const temperatureControlledCabinetHeater: DeviceTypeDefinition;
+export declare const dishwasher: DeviceTypeDefinition;
+export declare const laundryDryer: DeviceTypeDefinition;
+export declare const cookSurface: DeviceTypeDefinition;
+export declare const cooktop: DeviceTypeDefinition;
+export declare const oven: DeviceTypeDefinition;
+export declare const extractorHood: DeviceTypeDefinition;
+export declare const microwaveOven: DeviceTypeDefinition;
+export declare const evse: DeviceTypeDefinition;
+export declare const waterHeater: DeviceTypeDefinition;
+export declare const solarPower: DeviceTypeDefinition;
+export declare const batteryStorage: DeviceTypeDefinition;
+export declare const heatPump: DeviceTypeDefinition;

package/dist/matterbridgeDynamicPlatform.d.ts

@@ -0,0 +1,5 @@
+import { AnsiLogger } from 'node-ansi-logger';
+import { MatterbridgePlatform, PlatformConfig, PlatformMatterbridge } from './matterbridgePlatform.js';
+export declare class MatterbridgeDynamicPlatform extends MatterbridgePlatform {
+    constructor(matterbridge: PlatformMatterbridge, log: AnsiLogger, config: PlatformConfig);
+}

package/dist/matterbridgeEndpoint.d.ts

@@ -0,0 +1,175 @@
+import { AnsiLogger, LogLevel } from 'node-ansi-logger';
+import { NamedHandler, AtLeastOne } from '@matter/general';
+import { ActionContext, Behavior, Endpoint, ServerNode } from '@matter/node';
+import { ClusterType } from '@matter/types/cluster';
+import { EndpointNumber, ClusterId } from '@matter/types/datatype';
+import { Semtag } from '@matter/types/globals';
+import { PowerSource } from '@matter/types/clusters/power-source';
+import { Identify } from '@matter/types/clusters/identify';
+import { OnOff } from '@matter/types/clusters/on-off';
+import { ColorControl } from '@matter/types/clusters/color-control';
+import { WindowCovering } from '@matter/types/clusters/window-covering';
+import { FanControl } from '@matter/types/clusters/fan-control';
+import { DoorLock } from '@matter/types/clusters/door-lock';
+import { ModeSelect } from '@matter/types/clusters/mode-select';
+import { ValveConfigurationAndControl } from '@matter/types/clusters/valve-configuration-and-control';
+import { PumpConfigurationAndControl } from '@matter/types/clusters/pump-configuration-and-control';
+import { SmokeCoAlarm } from '@matter/types/clusters/smoke-co-alarm';
+import { AirQuality } from '@matter/types/clusters/air-quality';
+import { ConcentrationMeasurement } from '@matter/types/clusters/concentration-measurement';
+import { ThermostatUserInterfaceConfiguration } from '@matter/types/clusters/thermostat-user-interface-configuration';
+import { OperationalState } from '@matter/types/clusters/operational-state';
+import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
+import { DeviceEnergyManagementMode } from '@matter/types/clusters/device-energy-management-mode';
+import { ResourceMonitoring } from '@matter/types/clusters/resource-monitoring';
+import { DeviceTypeDefinition } from './matterbridgeDeviceTypes.js';
+import { CommandHandlerFunction, MatterbridgeEndpointCommands, MatterbridgeEndpointOptions, SerializedMatterbridgeEndpoint } from './matterbridgeEndpointTypes.js';
+export declare class MatterbridgeEndpoint extends Endpoint {
+    static logLevel: LogLevel;
+    mode: 'server' | 'matter' | undefined;
+    serverNode: ServerNode<ServerNode.RootEndpoint> | undefined;
+    log: AnsiLogger;
+    plugin: string | undefined;
+    configUrl: string | undefined;
+    deviceName: string | undefined;
+    serialNumber: string | undefined;
+    uniqueId: string | undefined;
+    vendorId: number | undefined;
+    vendorName: string | undefined;
+    productId: number | undefined;
+    productName: string | undefined;
+    softwareVersion: number | undefined;
+    softwareVersionString: string | undefined;
+    hardwareVersion: number | undefined;
+    hardwareVersionString: string | undefined;
+    productUrl: string;
+    tagList?: Semtag[];
+    originalId: string | undefined;
+    name: string | undefined;
+    deviceType: number | undefined;
+    readonly deviceTypes: Map<number, DeviceTypeDefinition>;
+    readonly commandHandler: NamedHandler<MatterbridgeEndpointCommands>;
+    constructor(definition: DeviceTypeDefinition | AtLeastOne<DeviceTypeDefinition>, options?: MatterbridgeEndpointOptions, debug?: boolean);
+    static loadInstance(definition: DeviceTypeDefinition | AtLeastOne<DeviceTypeDefinition>, options?: MatterbridgeEndpointOptions, debug?: boolean): Promise<MatterbridgeEndpoint>;
+    getDeviceTypes(): DeviceTypeDefinition[];
+    hasClusterServer(cluster: Behavior.Type | ClusterType | ClusterId | string): boolean;
+    hasAttributeServer(cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string): boolean;
+    getClusterServerOptions(cluster: Behavior.Type | ClusterType | ClusterId | string): Record<string, boolean | number | bigint | string | object | null> | undefined;
+    getAttribute(cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, log?: AnsiLogger): any;
+    setAttribute(clusterId: Behavior.Type | ClusterType | ClusterId | string, attribute: string, value: boolean | number | bigint | string | object | null, log?: AnsiLogger): Promise<boolean>;
+    updateAttribute(cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, value: boolean | number | bigint | string | object | null, log?: AnsiLogger): Promise<boolean>;
+    subscribeAttribute(cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, listener: (newValue: any, oldValue: any, context: ActionContext) => void, log?: AnsiLogger): Promise<boolean>;
+    triggerEvent(cluster: Behavior.Type | ClusterType | ClusterId | string, event: string, payload: Record<string, boolean | number | bigint | string | object | undefined | null>, log?: AnsiLogger): Promise<boolean>;
+    addClusterServers(serverList: ClusterId[]): this;
+    addFixedLabel(label: string, value: string): Promise<this>;
+    addUserLabel(label: string, value: string): Promise<this>;
+    addCommandHandler(command: keyof MatterbridgeEndpointCommands, handler: CommandHandlerFunction): this;
+    executeCommandHandler(command: keyof MatterbridgeEndpointCommands, request?: Record<string, boolean | number | bigint | string | object | null>, cluster?: string, attributes?: Record<string, boolean | number | bigint | string | object | null>, endpoint?: MatterbridgeEndpoint): Promise<void>;
+    invokeBehaviorCommand(cluster: Behavior.Type | ClusterType | ClusterId | string, command: keyof MatterbridgeEndpointCommands, params?: Record<string, boolean | number | bigint | string | object | null>): Promise<void>;
+    addRequiredClusterServers(): MatterbridgeEndpoint;
+    addOptionalClusterServers(): MatterbridgeEndpoint;
+    getAllClusterServers(): Behavior.Type[];
+    getAllClusterServerNames(): string[];
+    forEachAttribute(callback: (clusterName: string, clusterId: number, attributeName: string, attributeId: number, attributeValue: boolean | number | bigint | string | object | null | undefined) => void): void;
+    addChildDeviceType(endpointName: string, definition: DeviceTypeDefinition | AtLeastOne<DeviceTypeDefinition>, options?: MatterbridgeEndpointOptions, debug?: boolean): MatterbridgeEndpoint;
+    addChildDeviceTypeWithClusterServer(endpointName: string, definition: DeviceTypeDefinition | AtLeastOne<DeviceTypeDefinition>, serverList?: ClusterId[], options?: MatterbridgeEndpointOptions, debug?: boolean): MatterbridgeEndpoint;
+    getChildEndpointByName(endpointName: string): MatterbridgeEndpoint | undefined;
+    getChildEndpointById(id: string): MatterbridgeEndpoint | undefined;
+    getChildEndpointByOriginalId(originalId: string): MatterbridgeEndpoint | undefined;
+    getChildEndpoint(endpointNumber: EndpointNumber): MatterbridgeEndpoint | undefined;
+    getChildEndpoints(): MatterbridgeEndpoint[];
+    static serialize(device: MatterbridgeEndpoint): SerializedMatterbridgeEndpoint | undefined;
+    static deserialize(serializedDevice: SerializedMatterbridgeEndpoint): MatterbridgeEndpoint | undefined;
+    createDefaultPowerSourceWiredClusterServer(wiredCurrentType?: PowerSource.WiredCurrentType): this;
+    createDefaultPowerSourceBatteryClusterServer(batPercentRemaining?: null | number, batChargeLevel?: PowerSource.BatChargeLevel, batVoltage?: null | number, batReplaceability?: PowerSource.BatReplaceability): this;
+    createDefaultPowerSourceReplaceableBatteryClusterServer(batPercentRemaining?: number, batChargeLevel?: PowerSource.BatChargeLevel, batVoltage?: number, batReplacementDescription?: string, batQuantity?: number, batReplaceability?: PowerSource.BatReplaceability): this;
+    createDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining?: number, batChargeLevel?: PowerSource.BatChargeLevel, batVoltage?: number, batReplaceability?: PowerSource.BatReplaceability): this;
+    createDefaultBasicInformationClusterServer(deviceName: string, serialNumber: string, vendorId?: number, vendorName?: string, productId?: number, productName?: string, softwareVersion?: number, softwareVersionString?: string, hardwareVersion?: number, hardwareVersionString?: string): this;
+    createDefaultBridgedDeviceBasicInformationClusterServer(deviceName: string, serialNumber: string, vendorId?: number, vendorName?: string, productName?: string, softwareVersion?: number, softwareVersionString?: string, hardwareVersion?: number, hardwareVersionString?: string): this;
+    createDefaultPowerTopologyClusterServer(): this;
+    createDefaultElectricalEnergyMeasurementClusterServer(energyImported?: number | bigint | null, energyExported?: number | bigint | null): this;
+    createDefaultElectricalPowerMeasurementClusterServer(voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, frequency?: number | bigint | null): this;
+    createApparentElectricalPowerMeasurementClusterServer(voltage?: number | bigint | null, apparentCurrent?: number | bigint | null, apparentPower?: number | bigint | null, frequency?: number | bigint | null): this;
+    createDefaultDeviceEnergyManagementClusterServer(esaType?: DeviceEnergyManagement.EsaType, esaCanGenerate?: boolean, esaState?: DeviceEnergyManagement.EsaState, absMinPower?: number, absMaxPower?: number): this;
+    createDefaultDeviceEnergyManagementModeClusterServer(currentMode?: number, supportedModes?: DeviceEnergyManagementMode.ModeOption[]): this;
+    createDefaultIdentifyClusterServer(identifyTime?: number, identifyType?: Identify.IdentifyType): this;
+    createDefaultGroupsClusterServer(): this;
+    createDefaultScenesClusterServer(): this;
+    createDefaultOnOffClusterServer(onOff?: boolean, globalSceneControl?: boolean, onTime?: number, offWaitTime?: number, startUpOnOff?: OnOff.StartUpOnOff | null): this;
+    createOnOffClusterServer(onOff?: boolean): this;
+    createDeadFrontOnOffClusterServer(onOff?: boolean): this;
+    createOffOnlyOnOffClusterServer(onOff?: boolean): this;
+    createDefaultLevelControlClusterServer(currentLevel?: number, minLevel?: number, maxLevel?: number, onLevel?: number | null, startUpCurrentLevel?: number | null): this;
+    createLevelControlClusterServer(currentLevel?: number, onLevel?: number | null): this;
+    createDefaultColorControlClusterServer(currentX?: number, currentY?: number, currentHue?: number, currentSaturation?: number, colorTemperatureMireds?: number, colorTempPhysicalMinMireds?: number, colorTempPhysicalMaxMireds?: number): this;
+    createEnhancedColorControlClusterServer(currentX?: number, currentY?: number, enhancedCurrentHue?: number, currentSaturation?: number, colorTemperatureMireds?: number, colorTempPhysicalMinMireds?: number, colorTempPhysicalMaxMireds?: number): this;
+    createXyColorControlClusterServer(currentX?: number, currentY?: number, colorTemperatureMireds?: number, colorTempPhysicalMinMireds?: number, colorTempPhysicalMaxMireds?: number): this;
+    createHsColorControlClusterServer(currentHue?: number, currentSaturation?: number, colorTemperatureMireds?: number, colorTempPhysicalMinMireds?: number, colorTempPhysicalMaxMireds?: number): this;
+    createCtColorControlClusterServer(colorTemperatureMireds?: number, colorTempPhysicalMinMireds?: number, colorTempPhysicalMaxMireds?: number): this;
+    configureColorControlMode(colorMode: ColorControl.ColorMode): Promise<void>;
+    configureEnhancedColorControlMode(colorMode: ColorControl.EnhancedColorMode): Promise<void>;
+    createDefaultWindowCoveringClusterServer(positionPercent100ths?: number, type?: WindowCovering.WindowCoveringType, endProductType?: WindowCovering.EndProductType): this;
+    createDefaultLiftTiltWindowCoveringClusterServer(positionLiftPercent100ths?: number, positionTiltPercent100ths?: number, type?: WindowCovering.WindowCoveringType, endProductType?: WindowCovering.EndProductType): this;
+    setWindowCoveringTargetAsCurrentAndStopped(): Promise<void>;
+    setWindowCoveringCurrentTargetStatus(current: number, target: number, status: WindowCovering.MovementStatus): Promise<void>;
+    setWindowCoveringStatus(status: WindowCovering.MovementStatus): Promise<void>;
+    getWindowCoveringStatus(): WindowCovering.MovementStatus | undefined;
+    setWindowCoveringTargetAndCurrentPosition(liftPosition: number, tiltPosition?: number): Promise<void>;
+    createDefaultThermostatClusterServer(localTemperature?: number, occupiedHeatingSetpoint?: number, occupiedCoolingSetpoint?: number, minSetpointDeadBand?: number, minHeatSetpointLimit?: number, maxHeatSetpointLimit?: number, minCoolSetpointLimit?: number, maxCoolSetpointLimit?: number, unoccupiedHeatingSetpoint?: number | undefined, unoccupiedCoolingSetpoint?: number | undefined, occupied?: boolean | undefined, outdoorTemperature?: number | null | undefined): this;
+    createDefaultHeatingThermostatClusterServer(localTemperature?: number, occupiedHeatingSetpoint?: number, minHeatSetpointLimit?: number, maxHeatSetpointLimit?: number, unoccupiedHeatingSetpoint?: number | undefined, occupied?: boolean | undefined, outdoorTemperature?: number | null | undefined): this;
+    createDefaultCoolingThermostatClusterServer(localTemperature?: number, occupiedCoolingSetpoint?: number, minCoolSetpointLimit?: number, maxCoolSetpointLimit?: number, unoccupiedCoolingSetpoint?: number | undefined, occupied?: boolean | undefined, outdoorTemperature?: number | null | undefined): this;
+    createDefaultThermostatUserInterfaceConfigurationClusterServer(temperatureDisplayMode?: ThermostatUserInterfaceConfiguration.TemperatureDisplayMode, keypadLockout?: ThermostatUserInterfaceConfiguration.KeypadLockout, scheduleProgrammingVisibility?: ThermostatUserInterfaceConfiguration.ScheduleProgrammingVisibility): this;
+    createDefaultFanControlClusterServer(fanMode?: FanControl.FanMode, fanModeSequence?: FanControl.FanModeSequence, percentSetting?: number, percentCurrent?: number): this;
+    createOnOffFanControlClusterServer(fanMode?: FanControl.FanMode): this;
+    createBaseFanControlClusterServer(fanMode?: FanControl.FanMode, fanModeSequence?: FanControl.FanModeSequence, percentSetting?: number, percentCurrent?: number): this;
+    createMultiSpeedFanControlClusterServer(fanMode?: FanControl.FanMode, fanModeSequence?: FanControl.FanModeSequence, percentSetting?: number, percentCurrent?: number, speedMax?: number, speedSetting?: number, speedCurrent?: number): this;
+    createCompleteFanControlClusterServer(fanMode?: FanControl.FanMode, fanModeSequence?: FanControl.FanModeSequence, percentSetting?: number, percentCurrent?: number, speedMax?: number, speedSetting?: number, speedCurrent?: number, rockSupport?: {
+        rockLeftRight: boolean;
+        rockUpDown: boolean;
+        rockRound: boolean;
+    }, rockSetting?: {
+        rockLeftRight: boolean;
+        rockUpDown: boolean;
+        rockRound: boolean;
+    }, windSupport?: {
+        sleepWind: boolean;
+        naturalWind: boolean;
+    }, windSetting?: {
+        sleepWind: boolean;
+        naturalWind: boolean;
+    }, airflowDirection?: FanControl.AirflowDirection): this;
+    createDefaultHepaFilterMonitoringClusterServer(condition?: number, changeIndication?: ResourceMonitoring.ChangeIndication, inPlaceIndicator?: boolean | undefined, lastChangedTime?: number | null | undefined, replacementProductList?: ResourceMonitoring.ReplacementProduct[]): this;
+    createDefaultActivatedCarbonFilterMonitoringClusterServer(condition?: number, changeIndication?: ResourceMonitoring.ChangeIndication, inPlaceIndicator?: boolean | undefined, lastChangedTime?: number | null | undefined, replacementProductList?: ResourceMonitoring.ReplacementProduct[]): this;
+    createDefaultDoorLockClusterServer(lockState?: DoorLock.LockState, lockType?: DoorLock.LockType): this;
+    createDefaultModeSelectClusterServer(description: string, supportedModes: ModeSelect.ModeOption[], currentMode?: number, startUpMode?: number): this;
+    createDefaultValveConfigurationAndControlClusterServer(valveState?: ValveConfigurationAndControl.ValveState, valveLevel?: number): this;
+    createDefaultPumpConfigurationAndControlClusterServer(pumpMode?: PumpConfigurationAndControl.OperationMode): this;
+    createDefaultSmokeCOAlarmClusterServer(smokeState?: SmokeCoAlarm.AlarmState, coState?: SmokeCoAlarm.AlarmState): this;
+    createSmokeOnlySmokeCOAlarmClusterServer(smokeState?: SmokeCoAlarm.AlarmState): this;
+    createCoOnlySmokeCOAlarmClusterServer(coState?: SmokeCoAlarm.AlarmState): this;
+    createDefaultSwitchClusterServer(): this;
+    createDefaultMomentarySwitchClusterServer(): this;
+    createDefaultLatchingSwitchClusterServer(): this;
+    triggerSwitchEvent(event: 'Single' | 'Double' | 'Long' | 'Press' | 'Release', log?: AnsiLogger): Promise<boolean>;
+    createDefaultOperationalStateClusterServer(operationalState?: OperationalState.OperationalStateEnum): this;
+    createDefaultBooleanStateClusterServer(contact?: boolean): this;
+    createDefaultBooleanStateConfigurationClusterServer(sensorFault?: boolean, currentSensitivityLevel?: number, supportedSensitivityLevels?: number, defaultSensitivityLevel?: number): this;
+    createDefaultTemperatureMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): this;
+    createDefaultRelativeHumidityMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): this;
+    createDefaultPressureMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): this;
+    createDefaultIlluminanceMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): this;
+    createDefaultFlowMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): this;
+    createDefaultOccupancySensingClusterServer(occupied?: boolean, holdTime?: number, holdTimeMin?: number, holdTimeMax?: number): this;
+    createDefaultAirQualityClusterServer(airQuality?: AirQuality.AirQualityEnum): this;
+    createDefaultTvocMeasurementClusterServer(measuredValue?: number | null, measurementUnit?: ConcentrationMeasurement.MeasurementUnit, measurementMedium?: ConcentrationMeasurement.MeasurementMedium, uncertainty?: number): this;
+    createLevelTvocMeasurementClusterServer(levelValue?: ConcentrationMeasurement.LevelValue, measurementMedium?: ConcentrationMeasurement.MeasurementMedium): this;
+    createDefaultCarbonMonoxideConcentrationMeasurementClusterServer(measuredValue?: number | null, measurementUnit?: ConcentrationMeasurement.MeasurementUnit, measurementMedium?: ConcentrationMeasurement.MeasurementMedium): this;
+    createDefaultCarbonDioxideConcentrationMeasurementClusterServer(measuredValue?: number | null, measurementUnit?: ConcentrationMeasurement.MeasurementUnit, measurementMedium?: ConcentrationMeasurement.MeasurementMedium): this;
+    createDefaultFormaldehydeConcentrationMeasurementClusterServer(measuredValue?: number | null, measurementUnit?: ConcentrationMeasurement.MeasurementUnit, measurementMedium?: ConcentrationMeasurement.MeasurementMedium): this;
+    createDefaultPm1ConcentrationMeasurementClusterServer(measuredValue?: number | null, measurementUnit?: ConcentrationMeasurement.MeasurementUnit, measurementMedium?: ConcentrationMeasurement.MeasurementMedium): this;
+    createDefaultPm25ConcentrationMeasurementClusterServer(measuredValue?: number | null, measurementUnit?: ConcentrationMeasurement.MeasurementUnit, measurementMedium?: ConcentrationMeasurement.MeasurementMedium): this;
+    createDefaultPm10ConcentrationMeasurementClusterServer(measuredValue?: number | null, measurementUnit?: ConcentrationMeasurement.MeasurementUnit, measurementMedium?: ConcentrationMeasurement.MeasurementMedium): this;
+    createDefaultOzoneConcentrationMeasurementClusterServer(measuredValue?: number | null, measurementUnit?: ConcentrationMeasurement.MeasurementUnit, measurementMedium?: ConcentrationMeasurement.MeasurementMedium): this;
+    createDefaultRadonConcentrationMeasurementClusterServer(measuredValue?: number | null, measurementUnit?: ConcentrationMeasurement.MeasurementUnit, measurementMedium?: ConcentrationMeasurement.MeasurementMedium): this;
+    createDefaultNitrogenDioxideConcentrationMeasurementClusterServer(measuredValue?: number | null, measurementUnit?: ConcentrationMeasurement.MeasurementUnit, measurementMedium?: ConcentrationMeasurement.MeasurementMedium): this;
+}

package/dist/matterbridgeEndpointHelpers.d.ts

@@ -0,0 +1,362 @@
+import { AnsiLogger } from 'node-ansi-logger';
+import { ActionContext, Behavior, Endpoint } from '@matter/node';
+import { ClusterId } from '@matter/types/datatype';
+import { ClusterType } from '@matter/types/cluster';
+import { PowerSource } from '@matter/types/clusters/power-source';
+import { OperationalState } from '@matter/types/clusters/operational-state';
+import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
+import { DeviceEnergyManagementMode } from '@matter/types/clusters/device-energy-management-mode';
+import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
+import { MatterbridgeEndpointCommands } from './matterbridgeEndpointTypes.js';
+export declare function capitalizeFirstLetter(name: string): string;
+export declare function lowercaseFirstLetter(name: string): string;
+export declare function checkNotLatinCharacters(deviceName: string): boolean;
+export declare function generateUniqueId(deviceName: string): string;
+export declare function createUniqueId(param1: string, param2: string, param3: string, param4: string): string;
+export declare function featuresFor(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string): Record<string, boolean | undefined>;
+export declare function getBehaviourTypesFromClusterServerIds(clusterServerList: ClusterId[]): Behavior.Type[];
+export declare function getBehaviourTypesFromClusterClientIds(clusterClientList: ClusterId[]): Behavior.Type[];
+export declare function getBehaviourTypeFromClusterServerId(clusterId: ClusterId): Behavior.Type;
+export declare function getBehaviourTypeFromClusterClientId(_clusterId: ClusterId): void;
+export declare function getBehavior(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string): Behavior.Type | undefined;
+export declare function invokeBehaviorCommand(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, command: keyof MatterbridgeEndpointCommands, params?: Record<string, boolean | number | bigint | string | object | null>): Promise<boolean>;
+export declare function invokeSubscribeHandler(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, newValue: unknown, oldValue: unknown): Promise<boolean>;
+export declare function addRequiredClusterServers(endpoint: MatterbridgeEndpoint): void;
+export declare function addOptionalClusterServers(endpoint: MatterbridgeEndpoint): void;
+export declare function addClusterServers(endpoint: MatterbridgeEndpoint, serverList: ClusterId[]): void;
+export declare function addFixedLabel(endpoint: MatterbridgeEndpoint, label: string, value: string): Promise<void>;
+export declare function addUserLabel(endpoint: MatterbridgeEndpoint, label: string, value: string): Promise<void>;
+export declare function optionsFor<T extends Behavior.Type>(type: T, options: Behavior.Options<T>): Behavior.Options<T>;
+export declare function getClusterId(endpoint: Endpoint, cluster: string): number | undefined;
+export declare function getAttributeId(endpoint: Endpoint, cluster: string, attribute: string): number | undefined;
+export declare function getAttribute(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, log?: AnsiLogger): any;
+export declare function setAttribute(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, value: boolean | number | bigint | string | object | null, log?: AnsiLogger): Promise<boolean>;
+export declare function updateAttribute(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, value: boolean | number | bigint | string | object | null, log?: AnsiLogger): Promise<boolean>;
+export declare function subscribeAttribute(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, listener: (newValue: any, oldValue: any, context: ActionContext) => void, log?: AnsiLogger): Promise<boolean>;
+export declare function triggerEvent(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, event: string, payload: Record<string, boolean | number | bigint | string | object | undefined | null>, log?: AnsiLogger): Promise<boolean>;
+export declare function getDefaultPowerSourceWiredClusterServer(wiredCurrentType?: PowerSource.WiredCurrentType): Partial<{
+    status: number;
+    order: number;
+    endpointList: number[];
+    wiredAssessedInputVoltage?: number | null | undefined;
+    wiredAssessedInputFrequency?: number | null | undefined;
+    wiredAssessedCurrent?: number | null | undefined;
+    wiredPresent?: boolean | undefined;
+    activeWiredFaults?: number[] | undefined;
+    description: string;
+    wiredCurrentType: number;
+    wiredNominalVoltage?: number | undefined;
+    wiredMaximumCurrent?: number | undefined;
+}>;
+export declare function getDefaultPowerSourceBatteryClusterServer(batPercentRemaining?: null | number, batChargeLevel?: PowerSource.BatChargeLevel, batVoltage?: null | number, batReplaceability?: PowerSource.BatReplaceability): Partial<{
+    status: number;
+    order: number;
+    endpointList: number[];
+    batChargeLevel: number;
+    batReplacementNeeded: boolean;
+    batVoltage?: number | null | undefined;
+    batPercentRemaining?: number | null | undefined;
+    batTimeRemaining?: number | null | undefined;
+    batPresent?: boolean | undefined;
+    activeBatFaults?: number[] | undefined;
+    description: string;
+    batReplaceability: number;
+}>;
+export declare function getDefaultPowerSourceReplaceableBatteryClusterServer(batPercentRemaining?: number, batChargeLevel?: PowerSource.BatChargeLevel, batVoltage?: number, batReplacementDescription?: string, batQuantity?: number, batReplaceability?: PowerSource.BatReplaceability): Partial<{
+    status: number;
+    order: number;
+    endpointList: number[];
+    batChargeLevel: number;
+    batReplacementNeeded: boolean;
+    batVoltage?: number | null | undefined;
+    batPercentRemaining?: number | null | undefined;
+    batTimeRemaining?: number | null | undefined;
+    batPresent?: boolean | undefined;
+    activeBatFaults?: number[] | undefined;
+    description: string;
+    batReplaceability: number;
+    batReplacementDescription: string;
+    batQuantity: number;
+    batCommonDesignation?: number | undefined;
+    batAnsiDesignation?: string | undefined;
+    batIecDesignation?: string | undefined;
+    batApprovedChemistry?: number | undefined;
+    batCapacity?: number | undefined;
+}>;
+export declare function getDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining?: number, batChargeLevel?: PowerSource.BatChargeLevel, batVoltage?: number, batReplaceability?: PowerSource.BatReplaceability): Partial<{
+    status: number;
+    order: number;
+    endpointList: number[];
+    batChargeLevel: number;
+    batReplacementNeeded: boolean;
+    batChargeState: number;
+    batFunctionalWhileCharging: boolean;
+    batVoltage?: number | null | undefined;
+    batPercentRemaining?: number | null | undefined;
+    batTimeRemaining?: number | null | undefined;
+    batPresent?: boolean | undefined;
+    activeBatFaults?: number[] | undefined;
+    batTimeToFullCharge?: number | null | undefined;
+    batChargingCurrent?: number | null | undefined;
+    activeBatChargeFaults?: number[] | undefined;
+    description: string;
+    batReplaceability: number;
+    batCapacity?: number | undefined;
+}>;
+export declare function getDefaultElectricalEnergyMeasurementClusterServer(energyImported?: number | bigint | null, energyExported?: number | bigint | null): Partial<{
+    cumulativeEnergyImported: {
+        energy: number | bigint;
+        startTimestamp?: number | undefined;
+        endTimestamp?: number | undefined;
+        startSystime?: number | bigint | undefined;
+        endSystime?: number | bigint | undefined;
+    } | null;
+    cumulativeEnergyExported: {
+        energy: number | bigint;
+        startTimestamp?: number | undefined;
+        endTimestamp?: number | undefined;
+        startSystime?: number | bigint | undefined;
+        endSystime?: number | bigint | undefined;
+    } | null;
+    cumulativeEnergyReset?: {
+        importedResetTimestamp?: number | null | undefined;
+        exportedResetTimestamp?: number | null | undefined;
+        importedResetSystime?: number | bigint | null | undefined;
+        exportedResetSystime?: number | bigint | null | undefined;
+    } | null | undefined;
+    accuracy: {
+        measurementType: number;
+        measured: boolean;
+        minMeasuredValue: number | bigint;
+        maxMeasuredValue: number | bigint;
+        accuracyRanges: {
+            rangeMin: number | bigint;
+            rangeMax: number | bigint;
+            percentMax?: number | undefined;
+            percentMin?: number | undefined;
+            percentTypical?: number | undefined;
+            fixedMax?: number | bigint | undefined;
+            fixedMin?: number | bigint | undefined;
+            fixedTypical?: number | bigint | undefined;
+        }[];
+    };
+}>;
+export declare function getDefaultElectricalPowerMeasurementClusterServer(voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, frequency?: number | bigint | null): Partial<{
+    powerMode: number;
+    activePower: number | bigint | null;
+    ranges?: {
+        measurementType: number;
+        min: number | bigint;
+        max: number | bigint;
+        startTimestamp?: number | undefined;
+        endTimestamp?: number | undefined;
+        minTimestamp?: number | undefined;
+        maxTimestamp?: number | undefined;
+        startSystime?: number | bigint | undefined;
+        endSystime?: number | bigint | undefined;
+        minSystime?: number | bigint | undefined;
+        maxSystime?: number | bigint | undefined;
+    }[] | undefined;
+    voltage?: number | bigint | null | undefined;
+    activeCurrent?: number | bigint | null | undefined;
+    frequency?: number | bigint | null | undefined;
+    reactiveCurrent?: number | bigint | null | undefined;
+    apparentCurrent?: number | bigint | null | undefined;
+    reactivePower?: number | bigint | null | undefined;
+    apparentPower?: number | bigint | null | undefined;
+    rmsVoltage?: number | bigint | null | undefined;
+    rmsCurrent?: number | bigint | null | undefined;
+    rmsPower?: number | bigint | null | undefined;
+    powerFactor?: number | bigint | null | undefined;
+    numberOfMeasurementTypes: number;
+    accuracy: {
+        measurementType: number;
+        measured: boolean;
+        minMeasuredValue: number | bigint;
+        maxMeasuredValue: number | bigint;
+        accuracyRanges: {
+            rangeMin: number | bigint;
+            rangeMax: number | bigint;
+            percentMax?: number | undefined;
+            percentMin?: number | undefined;
+            percentTypical?: number | undefined;
+            fixedMax?: number | bigint | undefined;
+            fixedMin?: number | bigint | undefined;
+            fixedTypical?: number | bigint | undefined;
+        }[];
+    }[];
+}>;
+export declare function getApparentElectricalPowerMeasurementClusterServer(voltage?: number | bigint | null, apparentCurrent?: number | bigint | null, apparentPower?: number | bigint | null, frequency?: number | bigint | null): Partial<{
+    powerMode: number;
+    activePower: number | bigint | null;
+    ranges?: {
+        measurementType: number;
+        min: number | bigint;
+        max: number | bigint;
+        startTimestamp?: number | undefined;
+        endTimestamp?: number | undefined;
+        minTimestamp?: number | undefined;
+        maxTimestamp?: number | undefined;
+        startSystime?: number | bigint | undefined;
+        endSystime?: number | bigint | undefined;
+        minSystime?: number | bigint | undefined;
+        maxSystime?: number | bigint | undefined;
+    }[] | undefined;
+    voltage?: number | bigint | null | undefined;
+    activeCurrent?: number | bigint | null | undefined;
+    frequency?: number | bigint | null | undefined;
+    reactiveCurrent?: number | bigint | null | undefined;
+    apparentCurrent?: number | bigint | null | undefined;
+    reactivePower?: number | bigint | null | undefined;
+    apparentPower?: number | bigint | null | undefined;
+    rmsVoltage?: number | bigint | null | undefined;
+    rmsCurrent?: number | bigint | null | undefined;
+    rmsPower?: number | bigint | null | undefined;
+    powerFactor?: number | bigint | null | undefined;
+    numberOfMeasurementTypes: number;
+    accuracy: {
+        measurementType: number;
+        measured: boolean;
+        minMeasuredValue: number | bigint;
+        maxMeasuredValue: number | bigint;
+        accuracyRanges: {
+            rangeMin: number | bigint;
+            rangeMax: number | bigint;
+            percentMax?: number | undefined;
+            percentMin?: number | undefined;
+            percentTypical?: number | undefined;
+            fixedMax?: number | bigint | undefined;
+            fixedMin?: number | bigint | undefined;
+            fixedTypical?: number | bigint | undefined;
+        }[];
+    }[];
+}>;
+export declare function getDefaultDeviceEnergyManagementClusterServer(esaType?: DeviceEnergyManagement.EsaType, esaCanGenerate?: boolean, esaState?: DeviceEnergyManagement.EsaState, absMinPower?: number, absMaxPower?: number): Partial<{
+    powerAdjustmentCapability: {
+        powerAdjustCapability: {
+            minPower: number | bigint;
+            maxPower: number | bigint;
+            minDuration: number;
+            maxDuration: number;
+        }[] | null;
+        cause: number;
+    } | null;
+    forecast: {
+        forecastId: number;
+        activeSlotNumber: number | null;
+        startTime: number;
+        endTime: number;
+        isPausable: boolean;
+        slots: {
+            minDuration: number;
+            maxDuration: number;
+            defaultDuration: number;
+            elapsedSlotTime: number;
+            remainingSlotTime: number;
+            minPower?: number | bigint | undefined;
+            maxPower?: number | bigint | undefined;
+            slotIsPausable?: boolean | undefined;
+            minPauseDuration?: number | undefined;
+            maxPauseDuration?: number | undefined;
+            manufacturerEsaState?: number | undefined;
+            nominalPower?: number | bigint | undefined;
+            nominalEnergy?: number | bigint | undefined;
+            costs?: {
+                value: number;
+                costType: number;
+                decimalPoints: number;
+                currency?: number | undefined;
+            }[] | undefined;
+            minPowerAdjustment?: number | bigint | undefined;
+            maxPowerAdjustment?: number | bigint | undefined;
+            minDurationAdjustment?: number | undefined;
+            maxDurationAdjustment?: number | undefined;
+        }[];
+        forecastUpdateReason: number;
+        earliestStartTime?: number | null | undefined;
+        latestEndTime?: number | undefined;
+    } | null;
+    optOutState: number;
+    esaState: number;
+    absMinPower: number | bigint;
+    absMaxPower: number | bigint;
+    esaType: number;
+    esaCanGenerate: boolean;
+}>;
+export declare function getDefaultDeviceEnergyManagementModeClusterServer(currentMode?: number, supportedModes?: DeviceEnergyManagementMode.ModeOption[]): Partial<{
+    currentMode: number;
+    supportedModes: {
+        mode: number;
+        label: string;
+        modeTags: {
+            value: number;
+            mfgCode?: number | undefined;
+        }[];
+    }[];
+}>;
+export declare function getDefaultOperationalStateClusterServer(operationalState?: OperationalState.OperationalStateEnum): Partial<{
+    phaseList: string[] | null;
+    currentPhase: number | null;
+    operationalStateList: {
+        operationalStateId: number;
+        operationalStateLabel?: string | undefined;
+    }[];
+    operationalState: number;
+    operationalError: {
+        errorStateId: number;
+        errorStateLabel?: string | undefined;
+        errorStateDetails?: string | undefined;
+    };
+    countdownTime?: number | null | undefined;
+}>;
+export declare function getDefaultTemperatureMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): Partial<{
+    measuredValue: number | null;
+    minMeasuredValue: number | null;
+    maxMeasuredValue: number | null;
+    tolerance?: number | undefined;
+}>;
+export declare function getDefaultRelativeHumidityMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): Partial<{
+    measuredValue: number | null;
+    minMeasuredValue: number | null;
+    maxMeasuredValue: number | null;
+    tolerance?: number | undefined;
+}>;
+export declare function getDefaultPressureMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): Partial<{
+    measuredValue: number | null;
+    minMeasuredValue: number | null;
+    maxMeasuredValue: number | null;
+    tolerance?: number | undefined;
+}>;
+export declare function getDefaultIlluminanceMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): Partial<{
+    measuredValue: number | null;
+    minMeasuredValue: number | null;
+    maxMeasuredValue: number | null;
+    tolerance?: number | undefined;
+    lightSensorType?: number | null | undefined;
+}>;
+export declare function getDefaultFlowMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): Partial<{
+    measuredValue: number | null;
+    minMeasuredValue: number | null;
+    maxMeasuredValue: number | null;
+    tolerance?: number | undefined;
+}>;
+export declare function getDefaultOccupancySensingClusterServer(occupied?: boolean, holdTime?: number, holdTimeMin?: number, holdTimeMax?: number): Partial<{
+    occupancy: {
+        occupied?: boolean | undefined;
+    };
+    holdTime?: number | undefined;
+    pirOccupiedToUnoccupiedDelay?: number | undefined;
+    pirUnoccupiedToOccupiedDelay?: number | undefined;
+    pirUnoccupiedToOccupiedThreshold?: number | undefined;
+    occupancySensorType: number;
+    occupancySensorTypeBitmap: {
+        pir?: boolean | undefined;
+        ultrasonic?: boolean | undefined;
+        physicalContact?: boolean | undefined;
+    };
+    holdTimeLimits?: {
+        holdTimeMin: number;
+        holdTimeMax: number;
+        holdTimeDefault: number;
+    } | undefined;
+}>;