matterbridge 3.4.7-dev-20260103-3152357 → 3.4.7-dev-20260112-a00b2bf

package/dist/cli.d.ts

@@ -0,0 +1,6 @@
+import type { Matterbridge } from './matterbridge.js';
+import { Tracker } from './utils/tracker.js';
+import { Inspector } from './utils/inspector.js';
+export declare let instance: Matterbridge | undefined;
+export declare const tracker: Tracker;
+export declare const inspector: Inspector;

package/dist/cliEmitter.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from 'node:events';
+interface CliEvents {
+    shutdown: [];
+    cpu: [cpuUsage: number, processCpuUsage: number];
+    memory: [totalMememory: string, freeMemory: string, rss: string, heapTotal: string, heapUsed: string, external: string, arrayBuffers: string];
+    uptime: [systemUptime: string, processUptime: string];
+    ready: [];
+}
+export declare const cliEmitter: EventEmitter<CliEvents>;
+export declare let lastOsCpuUsage: number;
+export declare let lastProcessCpuUsage: number;
+export declare function setLastOsCpuUsage(val: number): void;
+export declare function setLastProcessCpuUsage(val: number): void;
+export {};

package/dist/cliHistory.d.ts

@@ -0,0 +1,6 @@
+export type GenerateHistoryPageOptions = {
+    outputPath?: string;
+    pageTitle?: string;
+    hostname?: string;
+};
+export declare function generateHistoryPage(options?: GenerateHistoryPageOptions): string | undefined;

package/dist/clusters/export.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/deviceManager.d.ts

@@ -0,0 +1,27 @@
+import { LogLevel } from 'node-ansi-logger';
+import type { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
+import { type BaseDevice } from './matterbridgeTypes.js';
+export declare function toBaseDevice(device: MatterbridgeEndpoint | BaseDevice): BaseDevice;
+export declare class DeviceManager {
+    private readonly _devices;
+    private readonly log;
+    private readonly server;
+    private readonly debug;
+    private readonly verbose;
+    constructor();
+    destroy(): void;
+    private msgHandler;
+    get length(): number;
+    get size(): number;
+    has(uniqueId: string): boolean;
+    get(uniqueId: string): MatterbridgeEndpoint | undefined;
+    set(device: MatterbridgeEndpoint): MatterbridgeEndpoint;
+    remove(device: MatterbridgeEndpoint): boolean;
+    clear(): void;
+    private toBaseDevice;
+    array(): MatterbridgeEndpoint[];
+    baseArray(pluginName?: string): BaseDevice[];
+    [Symbol.iterator](): MapIterator<MatterbridgeEndpoint>;
+    forEach(callback: (device: MatterbridgeEndpoint) => Promise<void>): Promise<void>;
+    set logLevel(logLevel: LogLevel);
+}

package/dist/devices/airConditioner.d.ts

@@ -0,0 +1,23 @@
+import { ThermostatUserInterfaceConfiguration } from '@matter/types/clusters/thermostat-user-interface-configuration';
+import { FanControl } from '@matter/types/clusters/fan-control';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export interface AirConditionerOptions {
+    localTemperature?: number;
+    occupiedHeatingSetpoint?: number;
+    occupiedCoolingSetpoint?: number;
+    minSetpointDeadBand?: number;
+    minHeatSetpointLimit?: number;
+    maxHeatSetpointLimit?: number;
+    minCoolSetpointLimit?: number;
+    maxCoolSetpointLimit?: number;
+    temperatureDisplayMode?: ThermostatUserInterfaceConfiguration.TemperatureDisplayMode;
+    keypadLockout?: ThermostatUserInterfaceConfiguration.KeypadLockout;
+    scheduleProgrammingVisibility?: ThermostatUserInterfaceConfiguration.ScheduleProgrammingVisibility;
+    fanMode?: FanControl.FanMode;
+    fanModeSequence?: FanControl.FanModeSequence;
+    percentSetting?: number;
+    percentCurrent?: number;
+}
+export declare class AirConditioner extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: AirConditionerOptions);
+}

package/dist/devices/batteryStorage.d.ts

@@ -0,0 +1,5 @@
+import { PowerSource } from '@matter/types/clusters/power-source';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export declare class BatteryStorage extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, batPercentRemaining?: number, batChargeLevel?: PowerSource.BatChargeLevel, voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, energyImported?: number | bigint | null, energyExported?: number | bigint | null, absMinPower?: number, absMaxPower?: number);
+}

package/dist/devices/cooktop.d.ts

@@ -0,0 +1,6 @@
+import { Semtag } from '@matter/types';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export declare class Cooktop extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string);
+    addSurface(name: string, tagList: Semtag[], selectedTemperatureLevel?: number, supportedTemperatureLevels?: string[]): MatterbridgeEndpoint;
+}

package/dist/devices/dishwasher.d.ts

@@ -0,0 +1,16 @@
+import { MaybePromise } from '@matter/general';
+import { OperationalState } from '@matter/types/clusters/operational-state';
+import { ModeBase } from '@matter/types/clusters/mode-base';
+import { DishwasherMode } from '@matter/types/clusters/dishwasher-mode';
+import { DishwasherModeServer } from '@matter/node/behaviors/dishwasher-mode';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export declare class Dishwasher extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, currentMode?: number, supportedModes?: DishwasherMode.ModeOption[], selectedTemperatureLevel?: number, supportedTemperatureLevels?: string[], temperatureSetpoint?: number, minTemperature?: number, maxTemperature?: number, step?: number, operationalState?: OperationalState.OperationalStateEnum);
+    createDefaultDishwasherModeClusterServer(currentMode?: number, supportedModes?: DishwasherMode.ModeOption[]): this;
+    createDefaultDishwasherAlarmClusterServer(): this;
+}
+export declare class MatterbridgeDishwasherModeServer extends DishwasherModeServer {
+    initialize(): void;
+    protected handleOnOffChange(onOff: boolean): void;
+    changeToMode(request: ModeBase.ChangeToModeRequest): MaybePromise<ModeBase.ChangeToModeResponse>;
+}

package/dist/devices/evse.d.ts

@@ -0,0 +1,19 @@
+import { MaybePromise } from '@matter/general';
+import { EnergyEvseMode } from '@matter/types/clusters/energy-evse-mode';
+import { EnergyEvse } from '@matter/types/clusters/energy-evse';
+import { ModeBase } from '@matter/types/clusters/mode-base';
+import { EnergyEvseServer } from '@matter/node/behaviors/energy-evse';
+import { EnergyEvseModeServer } from '@matter/node/behaviors/energy-evse-mode';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export declare class Evse extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, currentMode?: number, supportedModes?: EnergyEvseMode.ModeOption[], state?: EnergyEvse.State, supplyState?: EnergyEvse.SupplyState, faultState?: EnergyEvse.FaultState, voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, energy?: number | bigint | null, absMinPower?: number, absMaxPower?: number);
+    createDefaultEnergyEvseClusterServer(state?: EnergyEvse.State, supplyState?: EnergyEvse.SupplyState, faultState?: EnergyEvse.FaultState): this;
+    createDefaultEnergyEvseModeClusterServer(currentMode?: number, supportedModes?: EnergyEvseMode.ModeOption[]): this;
+}
+export declare class MatterbridgeEnergyEvseServer extends EnergyEvseServer {
+    disable(): MaybePromise;
+    enableCharging(request: EnergyEvse.EnableChargingRequest): MaybePromise;
+}
+export declare class MatterbridgeEnergyEvseModeServer extends EnergyEvseModeServer {
+    changeToMode(request: ModeBase.ChangeToModeRequest): MaybePromise<ModeBase.ChangeToModeResponse>;
+}

package/dist/devices/export.d.ts

@@ -0,0 +1,16 @@
+export * from './speaker.js';
+export * from './roboticVacuumCleaner.js';
+export * from './laundryWasher.js';
+export * from './laundryDryer.js';
+export * from './extractorHood.js';
+export * from './dishwasher.js';
+export * from './microwaveOven.js';
+export * from './oven.js';
+export * from './cooktop.js';
+export * from './refrigerator.js';
+export * from './airConditioner.js';
+export * from './waterHeater.js';
+export * from './evse.js';
+export * from './solarPower.js';
+export * from './batteryStorage.js';
+export * from './heatPump.js';

package/dist/devices/extractorHood.d.ts

@@ -0,0 +1,5 @@
+import { ResourceMonitoring } from '@matter/types/clusters/resource-monitoring';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export declare class ExtractorHood extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, hepaCondition?: number, hepaChangeIndication?: ResourceMonitoring.ChangeIndication, hepaInPlaceIndicator?: boolean | undefined, hepaLastChangedTime?: number | null | undefined, hepaReplacementProductList?: ResourceMonitoring.ReplacementProduct[], activatedCarbonCondition?: number, activatedCarbonChangeIndication?: ResourceMonitoring.ChangeIndication, activatedCarbonInPlaceIndicator?: boolean | undefined, activatedCarbonLastChangedTime?: number | null | undefined, activatedCarbonReplacementProductList?: ResourceMonitoring.ReplacementProduct[]);
+}

package/dist/devices/heatPump.d.ts

@@ -0,0 +1,4 @@
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export declare class HeatPump extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, energyImported?: number | bigint | null, absMinPower?: number, absMaxPower?: number);
+}

package/dist/devices/laundryDryer.d.ts

@@ -0,0 +1,9 @@
+import { OperationalState } from '@matter/types/clusters/operational-state';
+import { LaundryWasherMode } from '@matter/types/clusters/laundry-washer-mode';
+import { LaundryDryerControls } from '@matter/types/clusters/laundry-dryer-controls';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export declare class LaundryDryer extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, currentMode?: number, supportedModes?: LaundryWasherMode.ModeOption[], selectedTemperatureLevel?: number, supportedTemperatureLevels?: string[], temperatureSetpoint?: number, minTemperature?: number, maxTemperature?: number, step?: number, operationalState?: OperationalState.OperationalStateEnum);
+    createDefaultLaundryWasherModeClusterServer(currentMode?: number, supportedModes?: LaundryWasherMode.ModeOption[]): this;
+    createDefaultLaundryDryerControlsClusterServer(selectedDrynessLevel?: LaundryDryerControls.DrynessLevel, supportedDrynessLevels?: LaundryDryerControls.DrynessLevel[]): this;
+}

package/dist/devices/laundryWasher.d.ts

@@ -0,0 +1,17 @@
+import { MaybePromise } from '@matter/general';
+import { OperationalState } from '@matter/types/clusters/operational-state';
+import { LaundryWasherControls } from '@matter/types/clusters/laundry-washer-controls';
+import { LaundryWasherMode } from '@matter/types/clusters/laundry-washer-mode';
+import { ModeBase } from '@matter/types/clusters/mode-base';
+import { LaundryWasherModeServer } from '@matter/node/behaviors/laundry-washer-mode';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export declare class LaundryWasher extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, currentMode?: number, supportedModes?: LaundryWasherMode.ModeOption[], spinSpeedCurrent?: number, spinSpeeds?: string[], numberOfRinses?: LaundryWasherControls.NumberOfRinses, supportedRinses?: LaundryWasherControls.NumberOfRinses[], selectedTemperatureLevel?: number, supportedTemperatureLevels?: string[], temperatureSetpoint?: number, minTemperature?: number, maxTemperature?: number, step?: number, operationalState?: OperationalState.OperationalStateEnum);
+    createDefaultLaundryWasherModeClusterServer(currentMode?: number, supportedModes?: LaundryWasherMode.ModeOption[]): this;
+    createDefaultLaundryWasherControlsClusterServer(spinSpeedCurrent?: number, spinSpeeds?: string[], numberOfRinses?: LaundryWasherControls.NumberOfRinses, supportedRinses?: LaundryWasherControls.NumberOfRinses[]): this;
+}
+export declare class MatterbridgeLaundryWasherModeServer extends LaundryWasherModeServer {
+    initialize(): void;
+    protected handleOnOffChange(onOff: boolean): void;
+    changeToMode(request: ModeBase.ChangeToModeRequest): MaybePromise<ModeBase.ChangeToModeResponse>;
+}

package/dist/devices/microwaveOven.d.ts

@@ -0,0 +1,92 @@
+import { MaybePromise } from '@matter/general';
+import { MicrowaveOvenMode } from '@matter/types/clusters/microwave-oven-mode';
+import { MicrowaveOvenControl } from '@matter/types/clusters/microwave-oven-control';
+import { MicrowaveOvenControlServer } from '@matter/node/behaviors/microwave-oven-control';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export declare class MicrowaveOven extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, currentMode?: number, supportedModes?: MicrowaveOvenMode.ModeOption[], selectedWattIndex?: number, supportedWatts?: number[], cookTime?: number, maxCookTime?: number);
+    createDefaultMicrowaveOvenModeClusterServer(currentMode: number, supportedModes: MicrowaveOvenMode.ModeOption[]): this;
+    createDefaultMicrowaveOvenControlClusterServer(selectedWattIndex: number, supportedWatts: number[], cookTime: number, maxCookTime: number): this;
+}
+declare const MatterbridgeMicrowaveOvenControlServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
+    readonly id: 95;
+    readonly name: "MicrowaveOvenControl";
+    readonly revision: 1;
+    readonly features: {
+        readonly powerAsNumber: import("@matter/types").BitFlag;
+        readonly powerInWatts: import("@matter/types").BitFlag;
+        readonly powerNumberLimits: import("@matter/types").BitFlag;
+    };
+    readonly attributes: {
+        readonly cookTime: import("@matter/types").Attribute<number, any>;
+        readonly maxCookTime: import("@matter/types").FixedAttribute<number, any>;
+        readonly wattRating: import("@matter/types").OptionalFixedAttribute<number, any>;
+    };
+    readonly commands: {
+        readonly setCookingParameters: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+            cookMode: import("@matter/types").OptionalFieldType<number>;
+            cookTime: import("@matter/types").OptionalFieldType<number>;
+            powerSetting: import("@matter/types").OptionalFieldType<number>;
+            wattSettingIndex: import("@matter/types").OptionalFieldType<number>;
+            startAfterSetting: import("@matter/types").OptionalFieldType<boolean>;
+        }>, void, any>;
+        readonly addMoreTime: import("@matter/types").OptionalCommand<import("@matter/types").TypeFromFields<{
+            timeToAdd: import("@matter/types").FieldType<number>;
+        }>, void, any>;
+    };
+    readonly extensions: readonly [{
+        readonly flags: {
+            readonly powerAsNumber: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly powerSetting: import("@matter/types").Attribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly powerNumberLimits: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly minPower: import("@matter/types").FixedAttribute<number, any>;
+                readonly maxPower: import("@matter/types").FixedAttribute<number, any>;
+                readonly powerStep: import("@matter/types").FixedAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly powerInWatts: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly supportedWatts: import("@matter/types").FixedAttribute<number[], any>;
+                readonly selectedWattIndex: import("@matter/types").Attribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly powerNumberLimits: true;
+            readonly powerAsNumber: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly powerAsNumber: true;
+            readonly powerInWatts: true;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly powerAsNumber: false;
+            readonly powerInWatts: false;
+        };
+        readonly component: false;
+    }];
+}>, readonly [MicrowaveOvenControl.Feature.PowerInWatts]>, typeof MicrowaveOvenControlServer, import("@matter/node/behaviors/microwave-oven-control").MicrowaveOvenControlInterface>;
+export declare class MatterbridgeMicrowaveOvenControlServer extends MatterbridgeMicrowaveOvenControlServer_base {
+    initialize(): void;
+    setCookingParameters(request: MicrowaveOvenControl.SetCookingParametersRequest): MaybePromise;
+    addMoreTime(request: MicrowaveOvenControl.AddMoreTimeRequest): MaybePromise;
+}
+export {};

package/dist/devices/oven.d.ts

@@ -0,0 +1,23 @@
+import { MaybePromise } from '@matter/general';
+import { Semtag } from '@matter/types';
+import { ModeBase } from '@matter/types/clusters/mode-base';
+import { OvenMode } from '@matter/types/clusters/oven-mode';
+import { OperationalState } from '@matter/types/clusters/operational-state';
+import { OvenModeServer } from '@matter/node/behaviors/oven-mode';
+import { OvenCavityOperationalStateServer } from '@matter/node/behaviors/oven-cavity-operational-state';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export declare class Oven extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string);
+    addCabinet(name: string, tagList: Semtag[], currentMode?: number, supportedModes?: OvenMode.ModeOption[], selectedTemperatureLevel?: number, supportedTemperatureLevels?: string[], operationalState?: OperationalState.OperationalStateEnum, currentPhase?: number, phaseList?: string[]): MatterbridgeEndpoint;
+    createDefaultOvenModeClusterServer(endpoint: MatterbridgeEndpoint, currentMode: number, supportedModes: OvenMode.ModeOption[]): MatterbridgeEndpoint;
+    createDefaultOvenCavityOperationalStateClusterServer(endpoint: MatterbridgeEndpoint, operationalState?: OperationalState.OperationalStateEnum, currentPhase?: number, phaseList?: string[]): MatterbridgeEndpoint;
+}
+export declare class MatterbridgeOvenModeServer extends OvenModeServer {
+    initialize(): void;
+    changeToMode(request: ModeBase.ChangeToModeRequest): MaybePromise<ModeBase.ChangeToModeResponse>;
+}
+export declare class MatterbridgeOvenCavityOperationalStateServer extends OvenCavityOperationalStateServer {
+    initialize(): void;
+    stop(): MaybePromise<OperationalState.OperationalCommandResponse>;
+    start(): MaybePromise<OperationalState.OperationalCommandResponse>;
+}

package/dist/devices/refrigerator.d.ts

@@ -0,0 +1,18 @@
+import { MaybePromise } from '@matter/general';
+import { Semtag } from '@matter/types';
+import { ModeBase } from '@matter/types/clusters/mode-base';
+import { RefrigeratorAndTemperatureControlledCabinetMode } from '@matter/types/clusters/refrigerator-and-temperature-controlled-cabinet-mode';
+import { RefrigeratorAndTemperatureControlledCabinetModeServer } from '@matter/node/behaviors/refrigerator-and-temperature-controlled-cabinet-mode';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export declare class Refrigerator extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string);
+    addCabinet(name: string, tagList: Semtag[], currentMode?: number, supportedModes?: RefrigeratorAndTemperatureControlledCabinetMode.ModeOption[], selectedTemperatureLevel?: number, supportedTemperatureLevels?: string[], currentTemperature?: number): MatterbridgeEndpoint;
+    createDefaultRefrigeratorAndTemperatureControlledCabinetModeClusterServer(endpoint: MatterbridgeEndpoint, currentMode: number, supportedModes: RefrigeratorAndTemperatureControlledCabinetMode.ModeOption[]): MatterbridgeEndpoint;
+    createDefaultRefrigeratorAlarmClusterServer(endpoint: MatterbridgeEndpoint, doorOpen?: boolean): MatterbridgeEndpoint;
+    setDoorOpenState(cabinetName: string, doorOpen: boolean): Promise<MatterbridgeEndpoint | undefined>;
+    triggerDoorOpenState(cabinetName: string, doorOpen: boolean): Promise<MatterbridgeEndpoint | undefined>;
+}
+export declare class MatterbridgeRefrigeratorAndTemperatureControlledCabinetModeServer extends RefrigeratorAndTemperatureControlledCabinetModeServer {
+    initialize(): void;
+    changeToMode(request: ModeBase.ChangeToModeRequest): MaybePromise<ModeBase.ChangeToModeResponse>;
+}

package/dist/devices/roboticVacuumCleaner.d.ts

@@ -0,0 +1,29 @@
+import { MaybePromise } from '@matter/general';
+import { RvcRunMode } from '@matter/types/clusters/rvc-run-mode';
+import { RvcCleanMode } from '@matter/types/clusters/rvc-clean-mode';
+import { RvcOperationalState } from '@matter/types/clusters/rvc-operational-state';
+import { ServiceArea } from '@matter/types/clusters/service-area';
+import { ModeBase } from '@matter/types/clusters/mode-base';
+import { OperationalState } from '@matter/types/clusters/operational-state';
+import { RvcRunModeServer } from '@matter/node/behaviors/rvc-run-mode';
+import { RvcOperationalStateServer } from '@matter/node/behaviors/rvc-operational-state';
+import { RvcCleanModeServer } from '@matter/node/behaviors/rvc-clean-mode';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export declare class RoboticVacuumCleaner extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, mode?: 'server' | 'matter' | undefined, currentRunMode?: number, supportedRunModes?: RvcRunMode.ModeOption[], currentCleanMode?: number, supportedCleanModes?: RvcCleanMode.ModeOption[], currentPhase?: number | null, phaseList?: string[] | null, operationalState?: RvcOperationalState.OperationalState, operationalStateList?: RvcOperationalState.OperationalStateStruct[], supportedAreas?: ServiceArea.Area[], selectedAreas?: number[], currentArea?: number, supportedMaps?: ServiceArea.Map[]);
+    createDefaultRvcRunModeClusterServer(currentMode?: number, supportedModes?: RvcRunMode.ModeOption[]): this;
+    createDefaultRvcCleanModeClusterServer(currentMode?: number, supportedModes?: RvcCleanMode.ModeOption[]): this;
+    createDefaultServiceAreaClusterServer(supportedAreas?: ServiceArea.Area[], selectedAreas?: number[], currentArea?: number, supportedMaps?: ServiceArea.Map[]): this;
+    createDefaultRvcOperationalStateClusterServer(phaseList?: string[] | null, currentPhase?: number | null, operationalStateList?: RvcOperationalState.OperationalStateStruct[], operationalState?: RvcOperationalState.OperationalState, operationalError?: RvcOperationalState.ErrorStateStruct): this;
+}
+export declare class MatterbridgeRvcRunModeServer extends RvcRunModeServer {
+    changeToMode(request: ModeBase.ChangeToModeRequest): MaybePromise<ModeBase.ChangeToModeResponse>;
+}
+export declare class MatterbridgeRvcCleanModeServer extends RvcCleanModeServer {
+    changeToMode(request: ModeBase.ChangeToModeRequest): MaybePromise<ModeBase.ChangeToModeResponse>;
+}
+export declare class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateServer {
+    pause(): MaybePromise<OperationalState.OperationalCommandResponse>;
+    resume(): MaybePromise<OperationalState.OperationalCommandResponse>;
+    goHome(): MaybePromise<OperationalState.OperationalCommandResponse>;
+}

package/dist/devices/solarPower.d.ts

@@ -0,0 +1,4 @@
+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);
+}

package/dist/devices/speaker.d.ts

@@ -0,0 +1,8 @@
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export declare class Speaker extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, muted?: boolean, volume?: number);
+    setMuted(muted: boolean): Promise<void>;
+    isMuted(): boolean;
+    setVolume(level: number): Promise<void>;
+    getVolume(): number;
+}

package/dist/devices/temperatureControl.d.ts

@@ -0,0 +1,145 @@
+import { MaybePromise } from '@matter/general';
+import { TemperatureControl } from '@matter/types/clusters/temperature-control';
+import { TemperatureControlServer } from '@matter/node/behaviors/temperature-control';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export declare function createLevelTemperatureControlClusterServer(endpoint: MatterbridgeEndpoint, selectedTemperatureLevel?: number, supportedTemperatureLevels?: string[]): MatterbridgeEndpoint;
+export declare function createNumberTemperatureControlClusterServer(endpoint: MatterbridgeEndpoint, temperatureSetpoint?: number, minTemperature?: number, maxTemperature?: number, step?: number): MatterbridgeEndpoint;
+declare const MatterbridgeLevelTemperatureControlServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
+    readonly id: 86;
+    readonly name: "TemperatureControl";
+    readonly revision: 1;
+    readonly features: {
+        readonly temperatureNumber: import("@matter/types").BitFlag;
+        readonly temperatureLevel: import("@matter/types").BitFlag;
+        readonly temperatureStep: import("@matter/types").BitFlag;
+    };
+    readonly commands: {
+        readonly setTemperature: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+            targetTemperature: import("@matter/types").OptionalFieldType<number>;
+            targetTemperatureLevel: import("@matter/types").OptionalFieldType<number>;
+        }>, void, any>;
+    };
+    readonly extensions: readonly [{
+        readonly flags: {
+            readonly temperatureNumber: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly temperatureSetpoint: import("@matter/types").Attribute<number, any>;
+                readonly minTemperature: import("@matter/types").FixedAttribute<number, any>;
+                readonly maxTemperature: import("@matter/types").FixedAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly temperatureStep: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly step: import("@matter/types").FixedAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly temperatureLevel: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly selectedTemperatureLevel: import("@matter/types").Attribute<number, any>;
+                readonly supportedTemperatureLevels: import("@matter/types").Attribute<string[], any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly temperatureStep: true;
+            readonly temperatureNumber: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly temperatureNumber: true;
+            readonly temperatureLevel: true;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly temperatureNumber: false;
+            readonly temperatureLevel: false;
+        };
+        readonly component: false;
+    }];
+}>, readonly [TemperatureControl.Feature.TemperatureLevel]>, typeof TemperatureControlServer, import("@matter/node/behaviors/temperature-control").TemperatureControlInterface>;
+export declare class MatterbridgeLevelTemperatureControlServer extends MatterbridgeLevelTemperatureControlServer_base {
+    initialize(): void;
+    setTemperature(request: TemperatureControl.SetTemperatureRequest): MaybePromise;
+}
+declare const MatterbridgeNumberTemperatureControlServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
+    readonly id: 86;
+    readonly name: "TemperatureControl";
+    readonly revision: 1;
+    readonly features: {
+        readonly temperatureNumber: import("@matter/types").BitFlag;
+        readonly temperatureLevel: import("@matter/types").BitFlag;
+        readonly temperatureStep: import("@matter/types").BitFlag;
+    };
+    readonly commands: {
+        readonly setTemperature: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+            targetTemperature: import("@matter/types").OptionalFieldType<number>;
+            targetTemperatureLevel: import("@matter/types").OptionalFieldType<number>;
+        }>, void, any>;
+    };
+    readonly extensions: readonly [{
+        readonly flags: {
+            readonly temperatureNumber: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly temperatureSetpoint: import("@matter/types").Attribute<number, any>;
+                readonly minTemperature: import("@matter/types").FixedAttribute<number, any>;
+                readonly maxTemperature: import("@matter/types").FixedAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly temperatureStep: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly step: import("@matter/types").FixedAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly temperatureLevel: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly selectedTemperatureLevel: import("@matter/types").Attribute<number, any>;
+                readonly supportedTemperatureLevels: import("@matter/types").Attribute<string[], any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly temperatureStep: true;
+            readonly temperatureNumber: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly temperatureNumber: true;
+            readonly temperatureLevel: true;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly temperatureNumber: false;
+            readonly temperatureLevel: false;
+        };
+        readonly component: false;
+    }];
+}>, readonly [TemperatureControl.Feature.TemperatureNumber, TemperatureControl.Feature.TemperatureStep]>, typeof TemperatureControlServer, import("@matter/node/behaviors/temperature-control").TemperatureControlInterface>;
+export declare class MatterbridgeNumberTemperatureControlServer extends MatterbridgeNumberTemperatureControlServer_base {
+    initialize(): void;
+    setTemperature(request: TemperatureControl.SetTemperatureRequest): MaybePromise;
+}
+export {};

package/dist/devices/waterHeater.d.ts

@@ -0,0 +1,37 @@
+import { MaybePromise } from '@matter/general';
+import { ModeBase } from '@matter/types/clusters/mode-base';
+import { WaterHeaterManagement } from '@matter/types/clusters/water-heater-management';
+import { WaterHeaterMode } from '@matter/types/clusters/water-heater-mode';
+import { WaterHeaterManagementServer } from '@matter/node/behaviors/water-heater-management';
+import { WaterHeaterModeServer } from '@matter/node/behaviors/water-heater-mode';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export declare class WaterHeater extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, waterTemperature?: number, targetWaterTemperature?: number, minHeatSetpointLimit?: number, maxHeatSetpointLimit?: number, heaterTypes?: {
+        immersionElement1?: boolean;
+        immersionElement2?: boolean;
+        heatPump?: boolean;
+        boiler?: boolean;
+        other?: boolean;
+    }, tankPercentage?: number, voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, energy?: number | bigint | null, absMinPower?: number, absMaxPower?: number);
+    createDefaultWaterHeaterManagementClusterServer(heaterTypes?: {
+        immersionElement1?: boolean;
+        immersionElement2?: boolean;
+        heatPump?: boolean;
+        boiler?: boolean;
+        other?: boolean;
+    }, heatDemand?: {
+        immersionElement1?: boolean;
+        immersionElement2?: boolean;
+        heatPump?: boolean;
+        boiler?: boolean;
+        other?: boolean;
+    }, tankPercentage?: number, boostState?: WaterHeaterManagement.BoostState): this;
+    createDefaultWaterHeaterModeClusterServer(currentMode?: number, supportedModes?: WaterHeaterMode.ModeOption[]): this;
+}
+export declare class MatterbridgeWaterHeaterManagementServer extends WaterHeaterManagementServer {
+    boost(request: WaterHeaterManagement.BoostRequest): MaybePromise;
+    cancelBoost(): MaybePromise;
+}
+export declare class MatterbridgeWaterHeaterModeServer extends WaterHeaterModeServer {
+    changeToMode(request: ModeBase.ChangeToModeRequest): MaybePromise<ModeBase.ChangeToModeResponse>;
+}

package/dist/dgram/coap.d.ts

@@ -0,0 +1,34 @@
+import dgram from 'node:dgram';
+import { Multicast } from './multicast.js';
+export interface CoapMessage {
+    version: number;
+    type: number;
+    tokenLength: number;
+    code: number;
+    messageId: number;
+    token: Buffer;
+    options: CoapOption[];
+    payload?: Buffer;
+}
+interface CoapOption {
+    number: number;
+    value: Buffer;
+}
+export declare const COAP_OPTION_URI_PATH = 11;
+export declare const COIOT_OPTION_DEVID = 3332;
+export declare const COIOT_OPTION_VALIDITY = 3412;
+export declare const COIOT_OPTION_SERIAL = 3420;
+export declare const COIOT_REQUEST_STATUS_ID = 56831;
+export declare const COIOT_REQUEST_DESCRIPTION_ID = 56832;
+export declare class Coap extends Multicast {
+    constructor(name: string, multicastAddress: string, multicastPort: number, socketType: 'udp4' | 'udp6', reuseAddr?: boolean | undefined, interfaceName?: string, interfaceAddress?: string);
+    onCoapMessage(message: CoapMessage, rinfo: dgram.RemoteInfo): void;
+    onMessage(msg: Buffer, rinfo: dgram.RemoteInfo): void;
+    decodeCoapMessage(msg: Buffer): CoapMessage;
+    encodeCoapMessage(msg: CoapMessage): Buffer;
+    coapTypeToString(type: number): string;
+    coapCodeToString(code: number): string;
+    sendRequest(messageId: number, options: CoapOption[], payload: Record<string, any> | undefined, token: string | undefined, address: string | undefined, port: number | undefined): void;
+    logCoapMessage(msg: CoapMessage): void;
+}
+export {};