homebridge 2.0.0-beta.30 → 2.0.0-beta.32

package/dist/matter/matterServer.d.ts

@@ -0,0 +1,656 @@
+/**
+ * Matter.js Server Implementation for Homebridge Plugin API
+ *
+ * This provides a Matter bridge that plugins can use to register
+ * Matter accessories via the Homebridge API.
+ */
+import type { EndpointType } from '@matter/main';
+import type { SerializedMatterAccessory } from './matterAccessoryCache.js';
+import { EventEmitter } from 'node:events';
+import * as clusters from '@matter/main/clusters';
+import * as devices from '@matter/main/devices';
+import { MatterServerConfig } from './matterSharedTypes.js';
+import { MatterAccessory, MatterServerEvents } from './matterTypes.js';
+export { MatterServerConfig } from './matterSharedTypes.js';
+/**
+ * Matter Server for Homebridge Plugin API
+ * Allows plugins to register Matter accessories explicitly
+ *
+ * Extends EventEmitter to provide commissioning lifecycle events
+ */
+export declare class MatterServer extends EventEmitter {
+    on: <K extends keyof MatterServerEvents>(event: K, listener: MatterServerEvents[K]) => this;
+    emit: <K extends keyof MatterServerEvents>(event: K, ...args: Parameters<MatterServerEvents[K]>) => boolean;
+    removeListener: <K extends keyof MatterServerEvents>(event: K, listener: MatterServerEvents[K]) => this;
+    removeAllListeners: (event?: keyof MatterServerEvents) => this;
+    private readonly config;
+    private serverNode;
+    private aggregator;
+    private accessories;
+    private isRunning;
+    private readonly MAX_DEVICES;
+    private shutdownHandler;
+    private passcode;
+    private discriminator;
+    private readonly vendorId;
+    private readonly productId;
+    private commissioningInfo;
+    private serialNumber?;
+    private cleanupHandlers;
+    private storageManager;
+    private matterStoragePath?;
+    private accessoryCache;
+    private fabricMonitorInterval;
+    private previousFabrics;
+    constructor(config: MatterServerConfig);
+    /**
+     * Validate and sanitize Matter server configuration
+     * Throws descriptive errors if configuration is invalid
+     */
+    private validateAndSanitizeConfig;
+    /**
+     * Generate a secure random passcode
+     * According to Matter spec, passcode must be:
+     * - 8 digits (00000001 to 99999998)
+     * - Not in the invalid list
+     * - Not sequential or repeating patterns
+     */
+    private generateSecurePasscode;
+    /**
+     * Validate a passcode according to Matter specifications
+     */
+    private isValidPasscode;
+    /**
+     * Generate a random discriminator
+     * According to Matter spec, discriminator must be:
+     * - 12 bits (0-4095)
+     * - Should be random for security
+     */
+    private generateRandomDiscriminator;
+    /**
+     * Create ServerNode with automatic recovery from corrupted storage
+     *
+     * Matter.js can fail to start if fabric data is corrupted (common after
+     * hard shutdowns or disk errors). This method implements automatic recovery by:
+     *
+     * 1. Attempting normal ServerNode creation
+     * 2. If it fails with storage errors, identifying and removing corrupted files
+     * 3. Retrying ServerNode creation with fresh storage
+     *
+     * This prevents the need for manual intervention while preserving data
+     * safety by only removing storage on confirmed corruption errors.
+     *
+     * @param nodeOptions - Matter.js ServerNode configuration
+     * @param sanitizedId - Filesystem-safe bridge identifier
+     * @returns Initialized ServerNode instance
+     * @throws Error if recovery fails or error is not storage-related
+     */
+    private createServerNodeWithRecovery;
+    /**
+     * Start the Matter server
+     */
+    start(): Promise<void>;
+    /**
+     * Run the server after devices have been added (for external accessory mode)
+     * This must be called after registerPlatformAccessories() when using externalAccessory mode
+     */
+    runServer(): Promise<void>;
+    /**
+     * Set up and validate storage
+     */
+    private setupStorage;
+    /**
+     * Load or generate commissioning credentials (passcode and discriminator)
+     * These must be persistent across restarts to maintain the same QR code
+     */
+    private loadOrGenerateCredentials;
+    /**
+     * Generate and display commissioning information
+     */
+    private generateCommissioningInfo;
+    /**
+     * Wait for the server to be ready
+     */
+    private waitForServerReady;
+    /**
+     * Start monitoring fabric changes to emit commissioning events
+     */
+    private startFabricMonitoring;
+    /**
+     * Stop fabric monitoring
+     */
+    private stopFabricMonitoring;
+    /**
+     * Check for fabric changes and emit appropriate events
+     */
+    private checkFabricChanges;
+    /**
+     * Update commissioning info file when commissioning state changes
+     */
+    private updateCommissioningFile;
+    /**
+     * Register Matter platform accessories (Plugin API - matches HAP pattern)
+     */
+    registerPlatformAccessories(pluginIdentifier: string, platformName: string, accessories: MatterAccessory[]): Promise<void>;
+    /**
+     * Unregister Matter platform accessories (Plugin API - matches HAP pattern)
+     */
+    unregisterPlatformAccessories(pluginIdentifier: string, platformName: string, accessories: MatterAccessory[]): Promise<void>;
+    /**
+     * Register a single Matter accessory (internal method)
+     */
+    private registerAccessory;
+    /**
+     * Unregister a Matter accessory (Plugin API)
+     */
+    unregisterAccessory(uuid: string): Promise<void>;
+    /**
+     * Update a Matter accessory's state (Plugin API)
+     *
+     * This method can be called from anywhere, including from within handlers.
+     * State updates are automatically deferred to avoid transaction conflicts.
+     *
+     * @param uuid - The UUID of the accessory
+     * @param cluster - The cluster name
+     * @param attributes - The attributes to update
+     * @param partId - Optional: ID of the part to update (for composed devices)
+     */
+    updateAccessoryState(uuid: string, cluster: string, attributes: Record<string, unknown>, partId?: string): Promise<void>;
+    /**
+     * Get a Matter accessory's current state (Plugin API)
+     *
+     * Returns the current cluster attribute values that are exposed to Matter controllers.
+     * This is useful for:
+     * - Reading state after plugin restart (when local variables are lost)
+     * - Verifying current state before making changes
+     * - Multiple parts of code that need to read state
+     * - Debugging and logging
+     *
+     * @param uuid - The UUID of the accessory
+     * @param cluster - The cluster name (e.g., 'onOff', 'levelControl')
+     * @param partId - Optional: ID of the part to get state from (for composed devices)
+     * @returns Current cluster attribute values, or undefined if cluster not found
+     */
+    getAccessoryState(uuid: string, cluster: string, partId?: string): Record<string, unknown> | undefined;
+    /**
+     * Get all cached accessories (Internal - for restore process)
+     * @internal
+     */
+    getAllCachedAccessories(): SerializedMatterAccessory[];
+    /**
+     * Get all registered accessories (Plugin API)
+     */
+    getAccessories(): MatterAccessory[];
+    /**
+     * Get a specific accessory by UUID (Plugin API)
+     */
+    getAccessory(uuid: string): MatterAccessory | undefined;
+    /**
+     * Stop the Matter server
+     */
+    stop(): Promise<void>;
+    /**
+     * Cleanup resources
+     */
+    private cleanup;
+    /**
+     * Get fabric information for commissioned controllers
+     */
+    getFabricInfo(): Array<{
+        fabricIndex: number;
+        fabricId: string;
+        nodeId: string;
+        rootVendorId: number;
+        label?: string;
+    }>;
+    /**
+     * Check if the server is commissioned
+     */
+    isCommissioned(): boolean;
+    /**
+     * Get the number of commissioned fabrics
+     */
+    getCommissionedFabricCount(): number;
+    /**
+     * Get server status information
+     */
+    getServerInfo(): {
+        running: boolean;
+        port: number;
+        deviceCount: number;
+        commissioned: boolean;
+        fabricCount: number;
+        serialNumber?: string;
+    };
+    /**
+     * Get commissioning information
+     */
+    getCommissioningInfo(): {
+        qrCode?: string;
+        manualPairingCode?: string;
+        serialNumber?: string;
+        passcode?: number;
+        discriminator?: number;
+        commissioned: boolean;
+    };
+    /**
+     * Get storage statistics
+     */
+    getStorageStats(): Array<{
+        entries: number;
+        namespace: string;
+        path: string;
+    }> | null;
+    /**
+     * Check if server is running
+     */
+    isServerRunning(): boolean;
+    /**
+     * Get Matter device types available for plugin use
+     */
+    getDeviceTypes(): {
+        readonly OnOffLight: devices.OnOffLightDevice;
+        readonly DimmableLight: devices.DimmableLightDevice;
+        readonly ColorTemperatureLight: devices.ColorTemperatureLightDevice;
+        readonly ExtendedColorLight: devices.ExtendedColorLightDevice;
+        readonly OnOffSwitch: devices.OnOffLightSwitchDevice;
+        readonly OnOffOutlet: devices.OnOffPlugInUnitDevice;
+        readonly DimmableOutlet: devices.DimmablePlugInUnitDevice;
+        readonly TemperatureSensor: devices.TemperatureSensorDevice;
+        readonly HumiditySensor: devices.HumiditySensorDevice;
+        readonly LightSensor: devices.LightSensorDevice;
+        readonly MotionSensor: devices.OccupancySensorDevice;
+        readonly ContactSensor: devices.ContactSensorDevice;
+        readonly LeakSensor: devices.WaterLeakDetectorDevice;
+        readonly SmokeSensor: devices.SmokeCoAlarmDevice;
+        readonly Thermostat: import("@matter/main").MutableEndpoint.With<EndpointType.For<{
+            readonly name: "Thermostat";
+            readonly deviceType: 769;
+            readonly deviceRevision: 4;
+            readonly requirements: typeof devices.ThermostatRequirements;
+            readonly behaviors: {
+                readonly identify: typeof import("@matter/main/behaviors").IdentifyServer;
+            };
+        }>, import("@matter/main").SupportedBehaviors.With<{
+            readonly identify: typeof import("@matter/main/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: 8;
+            readonly features: {
+                readonly heating: import("@matter/types/schema").BitFlag;
+                readonly cooling: import("@matter/types/schema").BitFlag;
+                readonly occupancy: import("@matter/types/schema").BitFlag;
+                readonly scheduleConfiguration: import("@matter/types/schema").BitFlag;
+                readonly setback: import("@matter/types/schema").BitFlag;
+                readonly autoMode: import("@matter/types/schema").BitFlag;
+                readonly localTemperatureNotExposed: import("@matter/types/schema").BitFlag;
+                readonly matterScheduleConfiguration: import("@matter/types/schema").BitFlag;
+                readonly presets: import("@matter/types/schema").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/schema").TypeFromPartialBitSchema<{
+                    coolingStage: import("@matter/types/schema").BitField;
+                    heatingStage: import("@matter/types/schema").BitField;
+                    heatingIsHeatPump: import("@matter/types/schema").BitFlag;
+                    heatingUsesFuel: import("@matter/types/schema").BitFlag;
+                }>, any>;
+                readonly remoteSensing: import("@matter/types").OptionalWritableAttribute<import("@matter/types/schema").TypeFromPartialBitSchema<{
+                    localTemperature: import("@matter/types/schema").BitFlag;
+                    outdoorTemperature: import("@matter/types/schema").BitFlag;
+                    occupancy: import("@matter/types/schema").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/schema").TypeFromPartialBitSchema<{
+                    scheduleActive: import("@matter/types/schema").BitFlag;
+                    autoRecovery: import("@matter/types/schema").BitFlag;
+                    economy: import("@matter/types/schema").BitFlag;
+                }>, any>;
+                readonly thermostatRunningState: import("@matter/types").OptionalAttribute<import("@matter/types/schema").TypeFromPartialBitSchema<{
+                    heat: import("@matter/types/schema").BitFlag;
+                    cool: import("@matter/types/schema").BitFlag;
+                    fan: import("@matter/types/schema").BitFlag;
+                    heatStage2: import("@matter/types/schema").BitFlag;
+                    coolStage2: import("@matter/types/schema").BitFlag;
+                    fanStage2: import("@matter/types/schema").BitFlag;
+                    fanStage3: import("@matter/types/schema").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/schema").TypeFromPartialBitSchema<{
+                    compressorFail: import("@matter/types/schema").BitFlag;
+                    roomSensorFail: import("@matter/types/schema").BitFlag;
+                    outdoorSensorFail: import("@matter/types/schema").BitFlag;
+                    coilSensorFail: import("@matter/types/schema").BitFlag;
+                    fanFail: import("@matter/types/schema").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 extensions: readonly [{
+                readonly flags: {
+                    readonly occupancy: true;
+                };
+                readonly component: {
+                    readonly attributes: {
+                        readonly occupancy: import("@matter/types").Attribute<import("@matter/types/schema").TypeFromPartialBitSchema<{
+                            occupied: import("@matter/types/schema").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/schema").TypeFromPartialBitSchema<{
+                                sunday: import("@matter/types/schema").BitFlag;
+                                monday: import("@matter/types/schema").BitFlag;
+                                tuesday: import("@matter/types/schema").BitFlag;
+                                wednesday: import("@matter/types/schema").BitFlag;
+                                thursday: import("@matter/types/schema").BitFlag;
+                                friday: import("@matter/types/schema").BitFlag;
+                                saturday: import("@matter/types/schema").BitFlag;
+                                away: import("@matter/types/schema").BitFlag;
+                            }>>;
+                            modeForSequence: import("@matter/types").FieldType<import("@matter/types/schema").TypeFromPartialBitSchema<{
+                                heatSetpointPresent: import("@matter/types/schema").BitFlag;
+                                coolSetpointPresent: import("@matter/types/schema").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/schema").TypeFromPartialBitSchema<{
+                                sunday: import("@matter/types/schema").BitFlag;
+                                monday: import("@matter/types/schema").BitFlag;
+                                tuesday: import("@matter/types/schema").BitFlag;
+                                wednesday: import("@matter/types/schema").BitFlag;
+                                thursday: import("@matter/types/schema").BitFlag;
+                                friday: import("@matter/types/schema").BitFlag;
+                                saturday: import("@matter/types/schema").BitFlag;
+                                away: import("@matter/types/schema").BitFlag;
+                            }>>;
+                            modeToReturn: import("@matter/types").FieldType<import("@matter/types/schema").TypeFromPartialBitSchema<{
+                                heatSetpointPresent: import("@matter/types/schema").BitFlag;
+                                coolSetpointPresent: import("@matter/types/schema").BitFlag;
+                            }>>;
+                        }>, import("@matter/types").TypeFromFields<{
+                            numberOfTransitionsForSequence: import("@matter/types").FieldType<number>;
+                            dayOfWeekForSequence: import("@matter/types").FieldType<import("@matter/types/schema").TypeFromPartialBitSchema<{
+                                sunday: import("@matter/types/schema").BitFlag;
+                                monday: import("@matter/types/schema").BitFlag;
+                                tuesday: import("@matter/types/schema").BitFlag;
+                                wednesday: import("@matter/types/schema").BitFlag;
+                                thursday: import("@matter/types/schema").BitFlag;
+                                friday: import("@matter/types/schema").BitFlag;
+                                saturday: import("@matter/types/schema").BitFlag;
+                                away: import("@matter/types/schema").BitFlag;
+                            }>>;
+                            modeForSequence: import("@matter/types").FieldType<import("@matter/types/schema").TypeFromPartialBitSchema<{
+                                heatSetpointPresent: import("@matter/types/schema").BitFlag;
+                                coolSetpointPresent: import("@matter/types/schema").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/schema").TypeFromPartialBitSchema<{
+                                automatic: import("@matter/types/schema").BitFlag;
+                                supportsNames: import("@matter/types/schema").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/schema").TypeFromPartialBitSchema<{
+                                supportsPresets: import("@matter/types/schema").BitFlag;
+                                supportsSetpoints: import("@matter/types/schema").BitFlag;
+                                supportsNames: import("@matter/types/schema").BitFlag;
+                                supportsOff: import("@matter/types/schema").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/schema").TypeFromPartialBitSchema<{
+                                    sunday: import("@matter/types/schema").BitFlag;
+                                    monday: import("@matter/types/schema").BitFlag;
+                                    tuesday: import("@matter/types/schema").BitFlag;
+                                    wednesday: import("@matter/types/schema").BitFlag;
+                                    thursday: import("@matter/types/schema").BitFlag;
+                                    friday: import("@matter/types/schema").BitFlag;
+                                    saturday: import("@matter/types/schema").BitFlag;
+                                    away: import("@matter/types/schema").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/main/behaviors").ThermostatServer, import("@matter/main/behaviors").ThermostatInterface>]>>;
+        readonly Fan: devices.FanDevice;
+        readonly DoorLock: devices.DoorLockDevice;
+        readonly WindowCovering: devices.WindowCoveringDevice;
+        readonly RoboticVacuumCleaner: devices.RoboticVacuumCleanerDevice;
+        readonly GenericSwitch: devices.GenericSwitchDevice;
+        readonly Pump: devices.PumpDevice;
+        readonly RoomAirConditioner: devices.RoomAirConditionerDevice;
+    };
+    /**
+     * Get Matter clusters available for plugin use
+     */
+    getClusters(): typeof clusters;
+    /**
+     * Remove a specific fabric (controller) from the bridge
+     * This decommissions a single controller while leaving others intact
+     *
+     * @param fabricIndex - The fabric index to remove
+     * @returns Promise that resolves when the fabric is removed
+     */
+    removeFabric(fabricIndex: number): Promise<void>;
+    /**
+     * Check if a specific fabric exists
+     */
+    hasFabric(fabricIndex: number): boolean;
+    /**
+     * Notify controllers that the parts list has changed
+     * This triggers controllers (like Home app) to re-read the device list
+     * and discover new or removed accessories without needing to re-pair
+     */
+    private notifyPartsListChanged;
+}
+//# sourceMappingURL=matterServer.d.ts.map