homebridge 2.0.0-beta.4 → 2.0.0-beta.40

package/dist/matter/MatterAPIImpl.d.ts

@@ -0,0 +1,504 @@
+/**
+ * Matter API Implementation
+ *
+ * This class implements the Matter API facade, keeping Matter-specific logic
+ * separate from the core HomebridgeAPI class.
+ *
+ * Benefits:
+ * - Reduces changes to core api.ts file
+ * - Lazy-loads Matter code only when used
+ * - Clear separation between HAP and Matter
+ * - Easier to test in isolation
+ * - Validates accessories before registration
+ * - Provides detailed error messages for debugging
+ */
+import type { EndpointType } from '@matter/main';
+import type { HomebridgeAPI, MatterAPI, PlatformName, PluginIdentifier } from '../api.js';
+import { clusters, MatterAccessory } from './index.js';
+/**
+ * Implementation of the Matter API
+ * Delegates to the HomebridgeAPI instance for event emission and server access
+ * Provides validation and coordination for Matter accessory operations
+ */
+export declare class MatterAPIImpl implements MatterAPI {
+    private readonly api;
+    constructor(api: HomebridgeAPI);
+    /**
+     * Validate a Matter accessory has required fields
+     * @throws MatterAccessoryValidationError if validation fails
+     */
+    private validateAccessory;
+    /**
+     * Validate an array of accessories, logging errors for invalid ones
+     * @returns Array of valid accessories only
+     */
+    private validateAccessories;
+    /**
+     * Validate cluster name is valid
+     */
+    private validateClusterName;
+    /**
+     * UUID generator (alias of api.hap.uuid for convenience)
+     */
+    get uuid(): typeof import("hap-nodejs/dist/lib/util/uuid.js");
+    /**
+     * Matter device types for creating accessories
+     */
+    get deviceTypes(): {
+        readonly OnOffLight: import("@matter/node/devices").OnOffLightDevice;
+        readonly DimmableLight: import("@matter/node/devices").DimmableLightDevice;
+        readonly ColorTemperatureLight: import("@matter/node/devices").ColorTemperatureLightDevice;
+        readonly ExtendedColorLight: import("@matter/node/devices").ExtendedColorLightDevice;
+        readonly OnOffSwitch: import("@matter/node/devices").OnOffLightSwitchDevice;
+        readonly OnOffOutlet: import("@matter/node/devices").OnOffPlugInUnitDevice;
+        readonly DimmableOutlet: import("@matter/node/devices").DimmablePlugInUnitDevice;
+        readonly TemperatureSensor: import("@matter/node/devices").TemperatureSensorDevice;
+        readonly HumiditySensor: import("@matter/node/devices").HumiditySensorDevice;
+        readonly LightSensor: import("@matter/node/devices").LightSensorDevice;
+        readonly MotionSensor: import("@matter/node/devices").OccupancySensorDevice;
+        readonly ContactSensor: import("@matter/node/devices").ContactSensorDevice;
+        readonly LeakSensor: import("@matter/node/devices").WaterLeakDetectorDevice;
+        readonly SmokeSensor: import("@matter/node/devices").SmokeCoAlarmDevice;
+        readonly Thermostat: import("@matter/main").MutableEndpoint.With<EndpointType.For<{
+            readonly name: "Thermostat";
+            readonly deviceType: 769;
+            readonly deviceRevision: 4;
+            readonly requirements: typeof import("@matter/node/devices").ThermostatRequirements;
+            readonly behaviors: {
+                readonly identify: typeof import("@matter/node/behaviors").IdentifyServer;
+            };
+        }>, import("@matter/main").SupportedBehaviors.With<{
+            readonly identify: typeof import("@matter/node/behaviors").IdentifyServer;
+        }, readonly [import("@matter/main").ClusterBehavior.Type<import("@matter/types").ClusterComposer.WithFeatures<import("@matter/types").ClusterType.Of<{
+            readonly id: 513;
+            readonly name: "Thermostat";
+            readonly revision: 9;
+            readonly features: {
+                readonly heating: import("@matter/types").BitFlag;
+                readonly cooling: import("@matter/types").BitFlag;
+                readonly occupancy: import("@matter/types").BitFlag;
+                readonly scheduleConfiguration: import("@matter/types").BitFlag;
+                readonly setback: import("@matter/types").BitFlag;
+                readonly autoMode: import("@matter/types").BitFlag;
+                readonly localTemperatureNotExposed: import("@matter/types").BitFlag;
+                readonly matterScheduleConfiguration: import("@matter/types").BitFlag;
+                readonly presets: import("@matter/types").BitFlag;
+            };
+            readonly attributes: {
+                readonly localTemperature: import("@matter/types").Attribute<number | null, any>;
+                readonly outdoorTemperature: import("@matter/types").OptionalAttribute<number | null, any>;
+                readonly hvacSystemTypeConfiguration: import("@matter/types").OptionalWritableAttribute<import("@matter/types").TypeFromPartialBitSchema<{
+                    coolingStage: import("@matter/types").BitField;
+                    heatingStage: import("@matter/types").BitField;
+                    heatingIsHeatPump: import("@matter/types").BitFlag;
+                    heatingUsesFuel: import("@matter/types").BitFlag;
+                }>, any>;
+                readonly remoteSensing: import("@matter/types").OptionalWritableAttribute<import("@matter/types").TypeFromPartialBitSchema<{
+                    localTemperature: import("@matter/types").BitFlag;
+                    outdoorTemperature: import("@matter/types").BitFlag;
+                    occupancy: import("@matter/types").BitFlag;
+                }>, any>;
+                readonly controlSequenceOfOperation: import("@matter/types").WritableAttribute<clusters.Thermostat.ControlSequenceOfOperation, any>;
+                readonly systemMode: import("@matter/types").WritableAttribute<clusters.Thermostat.SystemMode, any>;
+                readonly temperatureSetpointHold: import("@matter/types").OptionalWritableAttribute<clusters.Thermostat.TemperatureSetpointHold, any>;
+                readonly temperatureSetpointHoldDuration: import("@matter/types").OptionalWritableAttribute<number | null, any>;
+                readonly thermostatProgrammingOperationMode: import("@matter/types").OptionalWritableAttribute<import("@matter/types").TypeFromPartialBitSchema<{
+                    scheduleActive: import("@matter/types").BitFlag;
+                    autoRecovery: import("@matter/types").BitFlag;
+                    economy: import("@matter/types").BitFlag;
+                }>, any>;
+                readonly thermostatRunningState: import("@matter/types").OptionalAttribute<import("@matter/types").TypeFromPartialBitSchema<{
+                    heat: import("@matter/types").BitFlag;
+                    cool: import("@matter/types").BitFlag;
+                    fan: import("@matter/types").BitFlag;
+                    heatStage2: import("@matter/types").BitFlag;
+                    coolStage2: import("@matter/types").BitFlag;
+                    fanStage2: import("@matter/types").BitFlag;
+                    fanStage3: import("@matter/types").BitFlag;
+                }>, any>;
+                readonly setpointChangeSource: import("@matter/types").OptionalAttribute<clusters.Thermostat.SetpointChangeSource, any>;
+                readonly setpointChangeAmount: import("@matter/types").OptionalAttribute<number | null, any>;
+                readonly setpointChangeSourceTimestamp: import("@matter/types").OptionalAttribute<number, any>;
+                readonly emergencyHeatDelta: import("@matter/types").OptionalWritableAttribute<number, any>;
+                readonly acType: import("@matter/types").OptionalWritableAttribute<clusters.Thermostat.AcType, any>;
+                readonly acCapacity: import("@matter/types").OptionalWritableAttribute<number, any>;
+                readonly acRefrigerantType: import("@matter/types").OptionalWritableAttribute<clusters.Thermostat.AcRefrigerantType, any>;
+                readonly acCompressorType: import("@matter/types").OptionalWritableAttribute<clusters.Thermostat.AcCompressorType, any>;
+                readonly acErrorCode: import("@matter/types").OptionalWritableAttribute<import("@matter/types").TypeFromPartialBitSchema<{
+                    compressorFail: import("@matter/types").BitFlag;
+                    roomSensorFail: import("@matter/types").BitFlag;
+                    outdoorSensorFail: import("@matter/types").BitFlag;
+                    coilSensorFail: import("@matter/types").BitFlag;
+                    fanFail: import("@matter/types").BitFlag;
+                }>, any>;
+                readonly acLouverPosition: import("@matter/types").OptionalWritableAttribute<clusters.Thermostat.AcLouverPosition, any>;
+                readonly acCoilTemperature: import("@matter/types").OptionalAttribute<number | null, any>;
+                readonly acCapacityFormat: import("@matter/types").OptionalWritableAttribute<clusters.Thermostat.AcCapacityFormat, any>;
+                readonly setpointHoldExpiryTimestamp: import("@matter/types").OptionalAttribute<number | null, any>;
+            };
+            readonly commands: {
+                readonly setpointRaiseLower: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+                    mode: import("@matter/types").FieldType<clusters.Thermostat.SetpointRaiseLowerMode>;
+                    amount: import("@matter/types").FieldType<number>;
+                }>, void, any>;
+                readonly atomicRequest: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+                    requestType: import("@matter/types").FieldType<clusters.Thermostat.RequestType>;
+                    attributeRequests: import("@matter/types").FieldType<import("@matter/main").AttributeId[]>;
+                    timeout: import("@matter/types").OptionalFieldType<number>;
+                }>, import("@matter/types").TypeFromFields<{
+                    statusCode: import("@matter/types").FieldType<import("@matter/types").Status>;
+                    attributeStatus: import("@matter/types").FieldType<import("@matter/types").TypeFromFields<{
+                        attributeId: import("@matter/types").FieldType<import("@matter/main").AttributeId>;
+                        statusCode: import("@matter/types").FieldType<import("@matter/types").Status>;
+                    }>[]>;
+                    timeout: import("@matter/types").OptionalFieldType<number>;
+                }>, any>;
+            };
+            readonly extensions: readonly [{
+                readonly flags: {
+                    readonly occupancy: true;
+                };
+                readonly component: {
+                    readonly attributes: {
+                        readonly occupancy: import("@matter/types").Attribute<import("@matter/types").TypeFromPartialBitSchema<{
+                            occupied: import("@matter/types").BitFlag;
+                        }>, any>;
+                    };
+                };
+            }, {
+                readonly flags: {
+                    readonly heating: true;
+                };
+                readonly component: {
+                    readonly attributes: {
+                        readonly absMinHeatSetpointLimit: import("@matter/types").OptionalFixedAttribute<number, any>;
+                        readonly absMaxHeatSetpointLimit: import("@matter/types").OptionalFixedAttribute<number, any>;
+                        readonly piHeatingDemand: import("@matter/types").OptionalAttribute<number, any>;
+                        readonly occupiedHeatingSetpoint: import("@matter/types").WritableAttribute<number, any>;
+                        readonly minHeatSetpointLimit: import("@matter/types").OptionalWritableAttribute<number, any>;
+                        readonly maxHeatSetpointLimit: import("@matter/types").OptionalWritableAttribute<number, any>;
+                    };
+                };
+            }, {
+                readonly flags: {
+                    readonly cooling: true;
+                };
+                readonly component: {
+                    readonly attributes: {
+                        readonly absMinCoolSetpointLimit: import("@matter/types").OptionalFixedAttribute<number, any>;
+                        readonly absMaxCoolSetpointLimit: import("@matter/types").OptionalFixedAttribute<number, any>;
+                        readonly piCoolingDemand: import("@matter/types").OptionalAttribute<number, any>;
+                        readonly occupiedCoolingSetpoint: import("@matter/types").WritableAttribute<number, any>;
+                        readonly minCoolSetpointLimit: import("@matter/types").OptionalWritableAttribute<number, any>;
+                        readonly maxCoolSetpointLimit: import("@matter/types").OptionalWritableAttribute<number, any>;
+                    };
+                };
+            }, {
+                readonly flags: {
+                    readonly localTemperatureNotExposed: false;
+                };
+                readonly component: {
+                    readonly attributes: {
+                        readonly localTemperatureCalibration: import("@matter/types").OptionalWritableAttribute<number, any>;
+                    };
+                };
+            }, {
+                readonly flags: {
+                    readonly cooling: true;
+                    readonly occupancy: true;
+                };
+                readonly component: {
+                    readonly attributes: {
+                        readonly unoccupiedCoolingSetpoint: import("@matter/types").WritableAttribute<number, any>;
+                    };
+                };
+            }, {
+                readonly flags: {
+                    readonly heating: true;
+                    readonly occupancy: true;
+                };
+                readonly component: {
+                    readonly attributes: {
+                        readonly unoccupiedHeatingSetpoint: import("@matter/types").WritableAttribute<number, any>;
+                    };
+                };
+            }, {
+                readonly flags: {
+                    readonly autoMode: true;
+                };
+                readonly component: {
+                    readonly attributes: {
+                        readonly minSetpointDeadBand: import("@matter/types").WritableAttribute<number, any>;
+                        readonly thermostatRunningMode: import("@matter/types").OptionalAttribute<clusters.Thermostat.ThermostatRunningMode, any>;
+                    };
+                };
+            }, {
+                readonly flags: {
+                    readonly scheduleConfiguration: true;
+                };
+                readonly component: {
+                    readonly attributes: {
+                        readonly startOfWeek: import("@matter/types").FixedAttribute<clusters.Thermostat.StartOfWeek, any>;
+                        readonly numberOfWeeklyTransitions: import("@matter/types").FixedAttribute<number, any>;
+                        readonly numberOfDailyTransitions: import("@matter/types").FixedAttribute<number, any>;
+                    };
+                    readonly commands: {
+                        readonly setWeeklySchedule: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+                            numberOfTransitionsForSequence: import("@matter/types").FieldType<number>;
+                            dayOfWeekForSequence: import("@matter/types").FieldType<import("@matter/types").TypeFromPartialBitSchema<{
+                                sunday: import("@matter/types").BitFlag;
+                                monday: import("@matter/types").BitFlag;
+                                tuesday: import("@matter/types").BitFlag;
+                                wednesday: import("@matter/types").BitFlag;
+                                thursday: import("@matter/types").BitFlag;
+                                friday: import("@matter/types").BitFlag;
+                                saturday: import("@matter/types").BitFlag;
+                                away: import("@matter/types").BitFlag;
+                            }>>;
+                            modeForSequence: import("@matter/types").FieldType<import("@matter/types").TypeFromPartialBitSchema<{
+                                heatSetpointPresent: import("@matter/types").BitFlag;
+                                coolSetpointPresent: import("@matter/types").BitFlag;
+                            }>>;
+                            transitions: import("@matter/types").FieldType<import("@matter/types").TypeFromFields<{
+                                transitionTime: import("@matter/types").FieldType<number>;
+                                heatSetpoint: import("@matter/types").FieldType<number | null>;
+                                coolSetpoint: import("@matter/types").FieldType<number | null>;
+                            }>[]>;
+                        }>, void, any>;
+                        readonly getWeeklySchedule: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+                            daysToReturn: import("@matter/types").FieldType<import("@matter/types").TypeFromPartialBitSchema<{
+                                sunday: import("@matter/types").BitFlag;
+                                monday: import("@matter/types").BitFlag;
+                                tuesday: import("@matter/types").BitFlag;
+                                wednesday: import("@matter/types").BitFlag;
+                                thursday: import("@matter/types").BitFlag;
+                                friday: import("@matter/types").BitFlag;
+                                saturday: import("@matter/types").BitFlag;
+                                away: import("@matter/types").BitFlag;
+                            }>>;
+                            modeToReturn: import("@matter/types").FieldType<import("@matter/types").TypeFromPartialBitSchema<{
+                                heatSetpointPresent: import("@matter/types").BitFlag;
+                                coolSetpointPresent: import("@matter/types").BitFlag;
+                            }>>;
+                        }>, import("@matter/types").TypeFromFields<{
+                            numberOfTransitionsForSequence: import("@matter/types").FieldType<number>;
+                            dayOfWeekForSequence: import("@matter/types").FieldType<import("@matter/types").TypeFromPartialBitSchema<{
+                                sunday: import("@matter/types").BitFlag;
+                                monday: import("@matter/types").BitFlag;
+                                tuesday: import("@matter/types").BitFlag;
+                                wednesday: import("@matter/types").BitFlag;
+                                thursday: import("@matter/types").BitFlag;
+                                friday: import("@matter/types").BitFlag;
+                                saturday: import("@matter/types").BitFlag;
+                                away: import("@matter/types").BitFlag;
+                            }>>;
+                            modeForSequence: import("@matter/types").FieldType<import("@matter/types").TypeFromPartialBitSchema<{
+                                heatSetpointPresent: import("@matter/types").BitFlag;
+                                coolSetpointPresent: import("@matter/types").BitFlag;
+                            }>>;
+                            transitions: import("@matter/types").FieldType<import("@matter/types").TypeFromFields<{
+                                transitionTime: import("@matter/types").FieldType<number>;
+                                heatSetpoint: import("@matter/types").FieldType<number | null>;
+                                coolSetpoint: import("@matter/types").FieldType<number | null>;
+                            }>[]>;
+                        }>, any>;
+                        readonly clearWeeklySchedule: import("@matter/types").Command<void, void, any>;
+                    };
+                };
+            }, {
+                readonly flags: {
+                    readonly setback: true;
+                };
+                readonly component: {
+                    readonly attributes: {
+                        readonly occupiedSetback: import("@matter/types").WritableAttribute<number | null, any>;
+                        readonly occupiedSetbackMin: import("@matter/types").FixedAttribute<number | null, any>;
+                        readonly occupiedSetbackMax: import("@matter/types").FixedAttribute<number | null, any>;
+                    };
+                };
+            }, {
+                readonly flags: {
+                    readonly setback: true;
+                    readonly occupancy: true;
+                };
+                readonly component: {
+                    readonly attributes: {
+                        readonly unoccupiedSetback: import("@matter/types").WritableAttribute<number | null, any>;
+                        readonly unoccupiedSetbackMin: import("@matter/types").FixedAttribute<number | null, any>;
+                        readonly unoccupiedSetbackMax: import("@matter/types").FixedAttribute<number | null, any>;
+                    };
+                };
+            }, {
+                readonly flags: {
+                    readonly presets: true;
+                };
+                readonly component: {
+                    readonly attributes: {
+                        readonly presetTypes: import("@matter/types").FixedAttribute<import("@matter/types").TypeFromFields<{
+                            presetScenario: import("@matter/types").FieldType<clusters.Thermostat.PresetScenario>;
+                            numberOfPresets: import("@matter/types").FieldType<number>;
+                            presetTypeFeatures: import("@matter/types").FieldType<import("@matter/types").TypeFromPartialBitSchema<{
+                                automatic: import("@matter/types").BitFlag;
+                                supportsNames: import("@matter/types").BitFlag;
+                            }>>;
+                        }>[], any>;
+                        readonly numberOfPresets: import("@matter/types").FixedAttribute<number, any>;
+                        readonly activePresetHandle: import("@matter/types").Attribute<AllowSharedBufferSource | null, any>;
+                        readonly presets: import("@matter/types").WritableAttribute<import("@matter/types").TypeFromFields<{
+                            presetHandle: import("@matter/types").FieldType<AllowSharedBufferSource | null>;
+                            presetScenario: import("@matter/types").FieldType<clusters.Thermostat.PresetScenario>;
+                            name: import("@matter/types").OptionalFieldType<string | null>;
+                            coolingSetpoint: import("@matter/types").OptionalFieldType<number>;
+                            heatingSetpoint: import("@matter/types").OptionalFieldType<number>;
+                            builtIn: import("@matter/types").FieldType<boolean | null>;
+                        }>[], any>;
+                    };
+                    readonly commands: {
+                        readonly setActivePresetRequest: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+                            presetHandle: import("@matter/types").FieldType<AllowSharedBufferSource | null>;
+                        }>, void, any>;
+                    };
+                };
+            }, {
+                readonly flags: {
+                    readonly matterScheduleConfiguration: true;
+                };
+                readonly component: {
+                    readonly attributes: {
+                        readonly scheduleTypes: import("@matter/types").FixedAttribute<import("@matter/types").TypeFromFields<{
+                            systemMode: import("@matter/types").FieldType<clusters.Thermostat.SystemMode>;
+                            numberOfSchedules: import("@matter/types").FieldType<number>;
+                            scheduleTypeFeatures: import("@matter/types").FieldType<import("@matter/types").TypeFromPartialBitSchema<{
+                                supportsPresets: import("@matter/types").BitFlag;
+                                supportsSetpoints: import("@matter/types").BitFlag;
+                                supportsNames: import("@matter/types").BitFlag;
+                                supportsOff: import("@matter/types").BitFlag;
+                            }>>;
+                        }>[], any>;
+                        readonly numberOfSchedules: import("@matter/types").FixedAttribute<number, any>;
+                        readonly numberOfScheduleTransitions: import("@matter/types").FixedAttribute<number, any>;
+                        readonly numberOfScheduleTransitionPerDay: import("@matter/types").FixedAttribute<number | null, any>;
+                        readonly activeScheduleHandle: import("@matter/types").Attribute<AllowSharedBufferSource | null, any>;
+                        readonly schedules: import("@matter/types").WritableAttribute<import("@matter/types").TypeFromFields<{
+                            scheduleHandle: import("@matter/types").FieldType<AllowSharedBufferSource | null>;
+                            systemMode: import("@matter/types").FieldType<clusters.Thermostat.SystemMode>;
+                            name: import("@matter/types").OptionalFieldType<string>;
+                            presetHandle: import("@matter/types").OptionalFieldType<AllowSharedBufferSource>;
+                            transitions: import("@matter/types").FieldType<import("@matter/types").TypeFromFields<{
+                                dayOfWeek: import("@matter/types").FieldType<import("@matter/types").TypeFromPartialBitSchema<{
+                                    sunday: import("@matter/types").BitFlag;
+                                    monday: import("@matter/types").BitFlag;
+                                    tuesday: import("@matter/types").BitFlag;
+                                    wednesday: import("@matter/types").BitFlag;
+                                    thursday: import("@matter/types").BitFlag;
+                                    friday: import("@matter/types").BitFlag;
+                                    saturday: import("@matter/types").BitFlag;
+                                    away: import("@matter/types").BitFlag;
+                                }>>;
+                                transitionTime: import("@matter/types").FieldType<number>;
+                                presetHandle: import("@matter/types").OptionalFieldType<AllowSharedBufferSource>;
+                                systemMode: import("@matter/types").OptionalFieldType<clusters.Thermostat.SystemMode>;
+                                coolingSetpoint: import("@matter/types").OptionalFieldType<number>;
+                                heatingSetpoint: import("@matter/types").OptionalFieldType<number>;
+                            }>[]>;
+                            builtIn: import("@matter/types").FieldType<boolean | null>;
+                        }>[], any>;
+                    };
+                    readonly commands: {
+                        readonly setActiveScheduleRequest: import("@matter/types").Command<import("@matter/types").TypeFromFields<{
+                            scheduleHandle: import("@matter/types").FieldType<AllowSharedBufferSource>;
+                        }>, void, any>;
+                    };
+                };
+            }, {
+                readonly flags: {
+                    readonly autoMode: true;
+                    readonly heating: false;
+                };
+                readonly component: false;
+            }, {
+                readonly flags: {
+                    readonly autoMode: true;
+                    readonly cooling: false;
+                };
+                readonly component: false;
+            }, {
+                readonly flags: {
+                    readonly heating: false;
+                    readonly cooling: false;
+                };
+                readonly component: false;
+            }];
+        }>, readonly ["Heating", "Cooling"]>, typeof import("@matter/node/behaviors").ThermostatServer, import("@matter/node/behaviors").ThermostatInterface>]>>;
+        readonly Fan: import("@matter/node/devices").FanDevice;
+        readonly DoorLock: import("@matter/node/devices").DoorLockDevice;
+        readonly WindowCovering: import("@matter/node/devices").WindowCoveringDevice;
+        readonly RoboticVacuumCleaner: import("@matter/node/devices").RoboticVacuumCleanerDevice;
+        readonly GenericSwitch: import("@matter/node/devices").GenericSwitchDevice;
+        readonly Pump: import("@matter/node/devices").PumpDevice;
+        readonly RoomAirConditioner: import("@matter/node/devices").RoomAirConditionerDevice;
+    };
+    /**
+     * Matter clusters - Direct access to Matter.js cluster definitions
+     */
+    get clusters(): typeof clusters;
+    /**
+     * Matter cluster names for type safety and autocomplete
+     */
+    get clusterNames(): {
+        readonly OnOff: "onOff";
+        readonly LevelControl: "levelControl";
+        readonly ColorControl: "colorControl";
+        readonly DoorLock: "doorLock";
+        readonly WindowCovering: "windowCovering";
+        readonly Thermostat: "thermostat";
+        readonly FanControl: "fanControl";
+        readonly TemperatureMeasurement: "temperatureMeasurement";
+        readonly RelativeHumidityMeasurement: "relativeHumidityMeasurement";
+        readonly IlluminanceMeasurement: "illuminanceMeasurement";
+        readonly OccupancySensing: "occupancySensing";
+        readonly BooleanState: "booleanState";
+        readonly SmokeCoAlarm: "smokeCoAlarm";
+        readonly RvcRunMode: "rvcRunMode";
+        readonly RvcOperationalState: "rvcOperationalState";
+        readonly RvcCleanMode: "rvcCleanMode";
+        readonly ServiceArea: "serviceArea";
+        readonly PumpConfigurationAndControl: "pumpConfigurationAndControl";
+        readonly Identify: "identify";
+        readonly BasicInformation: "basicInformation";
+        readonly BridgedDeviceBasicInformation: "bridgedDeviceBasicInformation";
+    };
+    /**
+     * Matter types - Access to Matter.js cluster type definitions and enums
+     */
+    get types(): typeof clusters;
+    /**
+     * Register Matter platform accessories
+     * Automatically handles external accessories (e.g., RoboticVacuumCleaner) that need dedicated bridges
+     * Validates accessories before registration
+     * Returns a promise that resolves when all accessories are fully registered
+     */
+    registerPlatformAccessories(pluginIdentifier: PluginIdentifier, platformName: PlatformName, accessories: MatterAccessory[]): Promise<void>;
+    /**
+     * Update Matter platform accessories in the cache
+     * Similar to api.updatePlatformAccessories() for HAP accessories
+     */
+    updatePlatformAccessories(accessories: MatterAccessory[]): Promise<void>;
+    /**
+     * Unregister Matter platform accessories
+     * Automatically handles external accessories (e.g., RoboticVacuumCleaner) that have dedicated bridges
+     */
+    unregisterPlatformAccessories(pluginIdentifier: PluginIdentifier, platformName: PlatformName, accessories: MatterAccessory[]): Promise<void>;
+    /**
+     * Update a Matter accessory's cluster state
+     * Validates inputs before updating
+     */
+    updateAccessoryState(uuid: string, cluster: string, attributes: Record<string, unknown>, partId?: string): Promise<void>;
+    /**
+     * Get a Matter accessory's current cluster state
+     * Checks both external servers and main bridge server
+     * Validates inputs before retrieving state
+     */
+    getAccessoryState(uuid: string, cluster: string, partId?: string): Promise<Record<string, unknown> | undefined>;
+}
+//# sourceMappingURL=MatterAPIImpl.d.ts.map

package/dist/matter/MatterAPIImpl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MatterAPIImpl.d.ts","sourceRoot":"","sources":["../../src/matter/MatterAPIImpl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAEhD,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAKzF,OAAO,EAAgB,QAAQ,EAAe,eAAe,EAA6B,MAAM,YAAY,CAAA;AA8B5G;;;;GAIG;AACH,qBAAa,aAAc,YAAW,SAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,GAAG;gBAAH,GAAG,EAAE,aAAa;IAE/C;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IA4CzB;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAoB3B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAW3B;;OAEG;IACH,IAAI,IAAI,sDAEP;IAED;;OAEG;IACH,IAAI,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uFA+Py+9B,uBAAuB;;4EAAmL,uBAAuB;;;;;;;;;;4EAAkpB,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;yFAAwwC,uBAAuB;;8EAAuL,uBAAuB;;;oFAAwO,uBAAuB;;;;;;;;;;;;;wFAAk2B,uBAAuB;;;;;;;;;;8EAAymB,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA7PtmmC;IAED;;OAEG;IACH,IAAI,QAAQ,oBAEX;IAED;;OAEG;IACH,IAAI,YAAY;;;;;;;;;;;;;;;;;;;;;;MAEf;IAED;;OAEG;IACH,IAAI,KAAK,oBAER;IAED;;;;;OAKG;IACG,2BAA2B,CAC/B,gBAAgB,EAAE,gBAAgB,EAClC,YAAY,EAAE,YAAY,EAC1B,WAAW,EAAE,eAAe,EAAE,GAC7B,OAAO,CAAC,IAAI,CAAC;IA8EhB;;;OAGG;IACG,yBAAyB,CAAC,WAAW,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAY9E;;;OAGG;IACG,6BAA6B,CACjC,gBAAgB,EAAE,gBAAgB,EAClC,YAAY,EAAE,YAAY,EAC1B,WAAW,EAAE,eAAe,EAAE,GAC7B,OAAO,CAAC,IAAI,CAAC;IAmChB;;;OAGG;IACG,oBAAoB,CACxB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC;IA2BhB;;;;OAIG;IACG,iBAAiB,CACrB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;CAqChD"}