homebridge 2.0.0-alpha.5 → 2.0.0-alpha.51

package/dist/matter/matterTypes.d.ts

@@ -0,0 +1,612 @@
+/**
+ * Matter Types for Homebridge Plugin API
+ *
+ * This module provides types and interfaces for plugin developers
+ * to create Matter-compatible accessories.
+ */
+import type { Endpoint, EndpointType } from '@matter/main';
+import * as clusters from '@matter/main/clusters';
+import * as devices from '@matter/main/devices';
+/**
+ * Matter command handler function type
+ *
+ * Handlers can be synchronous or asynchronous (returning a Promise).
+ * The args parameter contains the command arguments passed by Matter.js (optional).
+ */
+export type MatterCommandHandler<TArgs = unknown> = (args?: TArgs) => Promise<void> | void;
+/**
+ * Matter cluster handlers interface
+ *
+ * Maps command names to their handler functions.
+ * Each command can have custom argument types.
+ */
+export interface MatterClusterHandlers {
+    [commandName: string]: MatterCommandHandler<any>;
+}
+/**
+ * Matter Accessory - Plugin API Interface
+ *
+ * This is the main interface that plugin developers use to register
+ * Matter accessories with Homebridge.
+ */
+export interface MatterAccessory<T = Record<string, any>> {
+    /** Unique identifier for this accessory (must be unique across all accessories) */
+    uuid: string;
+    /** Display name for the accessory */
+    displayName: string;
+    /** Matter device type (e.g., OnOffLightDevice, DimmableLightDevice, etc.) */
+    deviceType: EndpointType;
+    /** Serial number for the device */
+    serialNumber: string;
+    /** Manufacturer name */
+    manufacturer: string;
+    /** Model name/identifier */
+    model: string;
+    /** Firmware revision (optional) */
+    firmwareRevision?: string;
+    /** Hardware revision (optional) */
+    hardwareRevision?: string;
+    /** Software version (optional) */
+    softwareVersion?: string;
+    /**
+     * Plugin developer storage - persists across restarts
+     * This is a way for plugin developers to store custom data with their accessory
+     * Similar to `PlatformAccessory.context` for HAP accessories
+     */
+    context?: T;
+    /**
+     * Initial cluster states
+     * Key is the cluster name, value is an object of attribute name -> value
+     *
+     * Example:
+     * {
+     *   onOff: { onOff: true },
+     *   levelControl: { currentLevel: 127, minLevel: 1, maxLevel: 254 }
+     * }
+     */
+    clusters: {
+        [clusterName: string]: {
+            [attributeName: string]: unknown;
+        };
+    };
+    /**
+     * Handlers for Matter commands (Home app → Device)
+     *
+     * These handlers are called when a user controls the accessory via the Home app.
+     * Use handlers to send commands to your actual device (cloud API, local network, etc.).
+     */
+    handlers?: {
+        [clusterName: string]: MatterClusterHandlers;
+    };
+    /**
+     * Optional: Get current state handler
+     * Called when a Matter controller reads an attribute
+     * If not provided, the last set value is returned
+     */
+    getState?: (cluster: string, attribute: string) => Promise<any> | any;
+}
+/**
+ * Matter Configuration (for bridge or child bridge)
+ */
+export interface MatterConfig extends Record<string, unknown> {
+    /** Port for Matter server (optional, will auto-assign if not specified) */
+    port?: number;
+    /** Name for the Matter bridge (optional) */
+    name?: string;
+}
+/**
+ * Matter Fabric Information
+ * Represents a commissioned controller (fabric) on the Matter bridge
+ */
+export interface MatterFabricInfo {
+    fabricIndex: number;
+    fabricId: string;
+    nodeId: string;
+    rootVendorId: number;
+    label?: string;
+}
+/**
+ * Matter Server Events
+ * Event types emitted by the Matter server for commissioning lifecycle
+ */
+export interface MatterServerEvents {
+    /** Emitted when the bridge is commissioned for the first time */
+    'commissioned': (fabricInfo: MatterFabricInfo) => void;
+    /** Emitted when the last fabric is removed (bridge becomes uncommissioned) */
+    'decommissioned': () => void;
+    /** Emitted when a new fabric (controller) is added */
+    'fabric-added': (fabricInfo: MatterFabricInfo) => void;
+    /** Emitted when a fabric (controller) is removed */
+    'fabric-removed': (fabricInfo: MatterFabricInfo) => void;
+    /** Emitted whenever commissioning state changes (any fabric added/removed) */
+    'commissioning-changed': (commissioned: boolean, fabricCount: number) => void;
+    /** Emitted when an accessory is registered */
+    'accessory-registered': (accessory: MatterAccessory) => void;
+    /** Emitted when an accessory is unregistered */
+    'accessory-unregistered': (uuid: string) => void;
+}
+/**
+ * Internal Matter accessory representation
+ * (Used internally by MatterServer)
+ */
+export interface InternalMatterAccessory extends MatterAccessory {
+    _associatedPlugin?: string;
+    _associatedPlatform?: string;
+    endpoint?: Endpoint;
+    registered: boolean;
+}
+/**
+ * Matter error type enum (for error handler categorization)
+ */
+export declare enum MatterErrorType {
+    INITIALIZATION = "INITIALIZATION",
+    NETWORK = "NETWORK",
+    COMMISSIONING = "COMMISSIONING",
+    DEVICE_SYNC = "DEVICE_SYNC",
+    SERVER = "SERVER",
+    STORAGE = "STORAGE",
+    CONFIGURATION = "CONFIGURATION",
+    DEVICE_ERROR = "DEVICE_ERROR",
+    UNKNOWN = "UNKNOWN"
+}
+/**
+ * Matter error details interface
+ */
+export interface MatterErrorDetails {
+    type?: MatterErrorType;
+    recoverable?: boolean;
+    code?: string;
+    context?: string;
+    originalError?: Error;
+}
+/**
+ * Matter error types
+ */
+export declare class MatterError extends Error {
+    readonly code: string;
+    readonly details?: MatterErrorDetails | undefined;
+    readonly type: MatterErrorType;
+    readonly timestamp: Date;
+    readonly recoverable: boolean;
+    constructor(message: string, code: string, details?: MatterErrorDetails | undefined, type?: MatterErrorType, recoverable?: boolean);
+}
+export declare class MatterCommissioningError extends MatterError {
+    constructor(message: string, details?: MatterErrorDetails);
+}
+export declare class MatterStorageError extends MatterError {
+    constructor(message: string, details?: MatterErrorDetails);
+}
+export declare class MatterDeviceError extends MatterError {
+    constructor(message: string, details?: MatterErrorDetails);
+}
+export declare class MatterNetworkError extends MatterError {
+    constructor(message: string, details?: MatterErrorDetails);
+}
+export { clusters };
+export { devices };
+/**
+ * Friendly device type names for the Plugin API
+ * Maps simplified names to actual Matter.js device types
+ */
+export declare const deviceTypes: {
+    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/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: 8;
+        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 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<Uint8Array<ArrayBufferLike> | null, any>;
+                    readonly presets: import("@matter/types").WritableAttribute<import("@matter/types").TypeFromFields<{
+                        presetHandle: import("@matter/types").FieldType<Uint8Array<ArrayBufferLike> | 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<Uint8Array<ArrayBufferLike> | 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<Uint8Array<ArrayBufferLike> | null, any>;
+                    readonly schedules: import("@matter/types").WritableAttribute<import("@matter/types").TypeFromFields<{
+                        scheduleHandle: import("@matter/types").FieldType<Uint8Array<ArrayBufferLike> | null>;
+                        systemMode: import("@matter/types").FieldType<clusters.Thermostat.SystemMode>;
+                        name: import("@matter/types").OptionalFieldType<string>;
+                        presetHandle: import("@matter/types").OptionalFieldType<Uint8Array<ArrayBufferLike>>;
+                        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<Uint8Array<ArrayBufferLike>>;
+                            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<Uint8Array<ArrayBufferLike>>;
+                    }>, 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: 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;
+};
+/**
+ * Matter Cluster Names
+ * Commonly used cluster names for type safety and autocomplete
+ * Use these with api.updateMatterAccessoryState() and api.getAccessoryState()
+ *
+ * @example
+ * ```typescript
+ * // With autocomplete and type safety:
+ * api.updateMatterAccessoryState(uuid, api.matterClusterNames.OnOff, { onOff: true })
+ * api.getAccessoryState(uuid, api.matterClusterNames.LevelControl)
+ * ```
+ */
+export declare const 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 PumpConfigurationAndControl: "pumpConfigurationAndControl";
+    readonly Identify: "identify";
+    readonly BasicInformation: "basicInformation";
+    readonly BridgedDeviceBasicInformation: "bridgedDeviceBasicInformation";
+};
+/**
+ * Type for Matter cluster names
+ * Provides type safety for cluster name strings
+ */
+export type MatterClusterName = typeof clusterNames[keyof typeof clusterNames];
+//# sourceMappingURL=matterTypes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"matterTypes.d.ts","sourceRoot":"","sources":["../../src/matter/matterTypes.ts"],"names":[],"mappings":"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"}