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

package/dist/matter/matterTypes.d.ts

@@ -0,0 +1,843 @@
+/**
+ * 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 { EventEmitter } from 'node:events';
+import * as clusters from '@matter/main/clusters';
+import * as devices from '@matter/main/devices';
+export type { EndpointType };
+/**
+ * Handler context information
+ * Provides information about which part of a composed device triggered the handler
+ */
+export interface MatterHandlerContext {
+    /** Parent accessory UUID */
+    uuid: string;
+    /** Part ID if this handler was triggered from a part, undefined for main accessory */
+    partId?: string;
+}
+/**
+ * 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).
+ * The context parameter provides information about which part triggered the handler (for composed devices).
+ */
+export type MatterCommandHandler<TArgs = unknown> = (args?: TArgs, context?: MatterHandlerContext) => 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 Part - Sub-device in a composed accessory
+ *
+ * Represents a child endpoint in a composed device (e.g., individual outlets in a power strip).
+ * Parts are added as child endpoints to the main accessory.
+ */
+export interface MatterAccessoryPart {
+    /** Unique identifier for this part within the accessory (e.g., 'outlet-1', 'light', 'shade') */
+    id: string;
+    /** Display name for this part (optional, defaults to parent's name + part id) */
+    displayName?: string;
+    /** Matter device type for this part */
+    deviceType: EndpointType;
+    /**
+     * Initial cluster states for this part
+     * Same format as `MatterAccessory.clusters`
+     */
+    clusters: {
+        [clusterName: string]: {
+            [attributeName: string]: unknown;
+        };
+    };
+    /**
+     * Handlers for this part's commands
+     * Handlers receive context.partId to identify which part was triggered
+     */
+    handlers?: {
+        [clusterName: string]: MatterClusterHandlers;
+    };
+}
+/**
+ * Matter Accessory - Plugin API Interface
+ *
+ * This is the main interface that plugin developers use to register
+ * Matter accessories with Homebridge.
+ *
+ * For composed devices (devices with multiple subcomponents), use the `parts` array
+ * to define child endpoints. Each part appears as a separate device in the Home app.
+ */
+export interface MatterAccessory<T = Record<string, unknown>> {
+    /** 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 }
+     * }
+     *
+     * Note: If using `parts`, this is optional (main accessory may only be a container)
+     */
+    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;
+    /**
+     * Optional: Array of child endpoints (parts) for composed devices
+     *
+     * Use this to create devices with multiple independent subcomponents, such as:
+     * - Power strip with multiple outlets
+     * - Window covering with shade + light
+     * - Multi-zone thermostat or speaker system
+     *
+     * Each part appears as a separate device in the Home app and can be controlled independently.
+     *
+     * Example:
+     * ```typescript
+     * parts: [
+     *   {
+     *     id: 'outlet-1',
+     *     displayName: 'Outlet 1',
+     *     deviceType: api.matter.deviceTypes.OnOffOutlet,
+     *     clusters: { onOff: { onOff: false } },
+     *     handlers: {
+     *       onOff: {
+     *         on: async (args, context) => {
+     *           console.log(`Part ${context.partId} turned on`)
+     *           await controlOutlet(1, true)
+     *         }
+     *       }
+     *     }
+     *   },
+     *   // ... more outlets
+     * ]
+     * ```
+     */
+    parts?: MatterAccessoryPart[];
+}
+/**
+ * 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;
+}
+/**
+ * Matter Accessory Event Types
+ *
+ * Events that can be emitted by Matter accessories during their lifecycle.
+ * These events follow the same pattern as HAP's AccessoryEventTypes to provide
+ * a consistent plugin development experience across both protocols.
+ *
+ * @example
+ * ```typescript
+ * Listen for when a Matter accessory is ready
+ * const accessory: MatterAccessory = { ... };
+ * api.matter.publishExternalAccessories('plugin-name', [accessory]);
+ *
+ * const internal = accessory as any;
+ * internal._eventEmitter?.on(MatterAccessoryEventTypes.READY, (port: number) => {
+ *   console.log(`Accessory ready on port ${port}`);
+ * });
+ * ```
+ *
+ * @group Matter Accessory
+ */
+export declare enum MatterAccessoryEventTypes {
+    /**
+     * Emitted when the Matter server is ready and the accessory is available on the network.
+     * This is the main event to listen for to know when an external accessory is ready.
+     *
+     * **HAP Equivalent:** `AccessoryEventTypes.ADVERTISED`
+     *
+     * @param port - The port number the Matter server is listening on
+     */
+    READY = "ready",
+    /**
+     * Emitted when a controller has commissioned (paired with) this accessory.
+     * This means a user has successfully added the accessory to their Matter controller
+     * (e.g., Apple Home, Google Home, Amazon Alexa).
+     *
+     * **HAP Equivalent:** `AccessoryEventTypes.PAIRED`
+     */
+    COMMISSIONED = "commissioned",
+    /**
+     * Emitted when a controller has decommissioned (unpaired from) this accessory.
+     * This typically happens when a user removes the accessory from their controller app.
+     *
+     * **HAP Equivalent:** `AccessoryEventTypes.UNPAIRED`
+     */
+    DECOMMISSIONED = "decommissioned"
+}
+/**
+ * Matter Accessory Event Emitter Interface
+ *
+ * Defines the typed event emitter interface for Matter accessories.
+ * This interface extends Node's EventEmitter to provide type-safe event handling
+ * for Matter accessory lifecycle events.
+ *
+ * **Usage Pattern (similar to HAP):**
+ * ```typescript
+ * const accessory: MatterAccessory = { ... };
+ * api.matter.publishExternalAccessories('plugin-name', [accessory]);
+ *
+ * Access the event emitter (note: created during registration)
+ * const internal = accessory as InternalMatterAccessory;
+ * internal._eventEmitter?.on(MatterAccessoryEventTypes.READY, (port: number) => {
+ *   console.log(`Accessory ready on port ${port}`);
+ * });
+ * ```
+ *
+ * @group Matter Accessory
+ */
+export interface MatterAccessoryEventEmitter extends EventEmitter {
+    /** Register listener for 'ready' event (fired when accessory is available on network) */
+    on: ((event: 'ready', listener: (port: number) => void) => this) & ((event: 'commissioned', listener: () => void) => this) & ((event: 'decommissioned', listener: () => void) => this);
+    /** Emit 'ready', 'commissioned', or 'decommissioned' event */
+    emit: ((event: 'ready', port: number) => boolean) & ((event: 'commissioned') => boolean) & ((event: 'decommissioned') => boolean);
+}
+/**
+ * Internal representation of a part endpoint
+ */
+export interface InternalMatterAccessoryPart extends MatterAccessoryPart {
+    /** Matter.js endpoint instance for this part */
+    endpoint?: Endpoint;
+}
+/**
+ * Internal Matter accessory representation
+ * (Used internally by MatterServer)
+ *
+ * @internal
+ */
+export interface InternalMatterAccessory extends MatterAccessory {
+    /** Plugin identifier (set when registered) */
+    _associatedPlugin?: string;
+    /** Platform name (set when registered) */
+    _associatedPlatform?: string;
+    /** Matter.js endpoint instance */
+    endpoint?: Endpoint;
+    /** Whether this accessory is currently registered */
+    registered: boolean;
+    /** Internal part endpoints (if using parts) */
+    _parts?: InternalMatterAccessoryPart[];
+    /**
+     * Event emitter for accessory lifecycle events (ready, commissioned, decommissioned).
+     *
+     * Created during accessory registration. Plugins can listen to these events to know
+     * when an external accessory is available on the network.
+     *
+     * **HAP Equivalent:** Similar to `PlatformAccessory._associatedHAPAccessory` events
+     *
+     * @example
+     * ```typescript
+     * const accessory: MatterAccessory = { ... };
+     * api.matter.publishExternalAccessories('plugin', [accessory]);
+     *
+     * Cast to internal type to access event emitter
+     * const internal = accessory as InternalMatterAccessory;
+     * internal._eventEmitter?.on(MatterAccessoryEventTypes.READY, (port) => {
+     *   console.log(`Accessory ready on port ${port}`);
+     * });
+     * ```
+     */
+    _eventEmitter?: MatterAccessoryEventEmitter;
+}
+/**
+ * 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);
+}
+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<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: 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 ServiceArea: "serviceArea";
+    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];
+/**
+ * Type-safe accessory map for MatterServer
+ */
+export type MatterAccessoryMap = Map<string, InternalMatterAccessory>;
+/**
+ * Check if endpoint has state property (runtime check)
+ */
+export declare function hasEndpointState(endpoint: Endpoint): boolean;
+/**
+ * Safely update endpoint state
+ * Uses the Endpoint's set method to update cluster attributes
+ */
+export declare function updateEndpointState(endpoint: Endpoint, cluster: string, attributes: Record<string, unknown>): Promise<void>;
+/**
+ * Device type with behaviors (internal Matter.js structure)
+ */
+export interface DeviceTypeWithBehaviors extends EndpointType {
+    with: (...behaviors: any[]) => DeviceTypeWithBehaviors;
+}
+/**
+ * WindowCovering cluster with dynamic attributes
+ */
+export interface WindowCoveringCluster {
+    type?: number;
+    configStatus?: {
+        liftPositionAware?: boolean;
+        tiltPositionAware?: boolean;
+        liftEncoderControlled?: boolean;
+        tiltEncoderControlled?: boolean;
+    };
+    targetPositionLiftPercent100ths?: number;
+    currentPositionLiftPercent100ths?: number;
+    targetPositionTiltPercent100ths?: number;
+    currentPositionTiltPercent100ths?: number;
+    operationalStatus?: number;
+}
+/**
+ * Type-safe cluster access for WindowCovering
+ */
+export declare function getWindowCoveringCluster(accessory: MatterAccessory): WindowCoveringCluster | undefined;
+//# sourceMappingURL=matterTypes.d.ts.map