@matterbridge/core 3.5.3

package/dist/matterbridgeEndpointHelpers.d.ts

@@ -0,0 +1,1855 @@
+/**
+ * This file contains the helpers for the class MatterbridgeEndpoint.
+ *
+ * @file matterbridgeEndpointHelpers.ts
+ * @author Luca Liguori
+ * @created 2024-10-01
+ * @version 2.1.0
+ * @license Apache-2.0
+ *
+ * Copyright 2024, 2025, 2026 Luca Liguori.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AnsiLogger } from 'node-ansi-logger';
+import { ActionContext, Behavior, ClusterBehavior, Endpoint } from '@matter/node';
+import { ClusterId } from '@matter/types/datatype';
+import { MeasurementType } from '@matter/types/globals';
+import { ClusterType } from '@matter/types/cluster';
+import { PowerSource } from '@matter/types/clusters/power-source';
+import { ElectricalPowerMeasurement } from '@matter/types/clusters/electrical-power-measurement';
+import { ElectricalEnergyMeasurement } from '@matter/types/clusters/electrical-energy-measurement';
+import { TemperatureMeasurement } from '@matter/types/clusters/temperature-measurement';
+import { RelativeHumidityMeasurement } from '@matter/types/clusters/relative-humidity-measurement';
+import { PressureMeasurement } from '@matter/types/clusters/pressure-measurement';
+import { FlowMeasurement } from '@matter/types/clusters/flow-measurement';
+import { IlluminanceMeasurement } from '@matter/types/clusters/illuminance-measurement';
+import { OccupancySensing } from '@matter/types/clusters/occupancy-sensing';
+import { OperationalState } from '@matter/types/clusters/operational-state';
+import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
+import { DeviceEnergyManagementMode } from '@matter/types/clusters/device-energy-management-mode';
+import { ElectricalPowerMeasurementServer } from '@matter/node/behaviors/electrical-power-measurement';
+import { ElectricalEnergyMeasurementServer } from '@matter/node/behaviors/electrical-energy-measurement';
+import { OccupancySensingServer } from '@matter/node/behaviors/occupancy-sensing';
+import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
+import { MatterbridgeEndpointCommands } from './matterbridgeEndpointTypes.js';
+import { MatterbridgeOperationalStateServer, MatterbridgePowerSourceServer, MatterbridgeDeviceEnergyManagementServer, MatterbridgeDeviceEnergyManagementModeServer } from './matterbridgeBehaviors.js';
+/**
+ *  Capitalizes the first letter of a string.
+ *
+ * @param {string} name - The string to capitalize.
+ * @returns {string} The string with the first letter capitalized.
+ */
+export declare function capitalizeFirstLetter(name: string): string;
+/**
+ * Lowercases the first letter of a string.
+ *
+ * @param {string} name - The string to lowercase the first letter of.
+ * @returns {string} The string with the first letter lowercased.
+ */
+export declare function lowercaseFirstLetter(name: string): string;
+/**
+ * Checks if the device name contains non-Latin characters.
+ *
+ * @param {string} deviceName - The name of the device to check.
+ * @returns {boolean} Returns true if the device name contains non-Latin characters, false otherwise.
+ */
+export declare function checkNotLatinCharacters(deviceName: string): boolean;
+/**
+ * Generates a unique ID based on the device name.
+ *
+ * @param {string} deviceName - The name of the device to generate a unique ID for.
+ * @returns {string} A unique ID generated from the device name using MD5 hashing.
+ */
+export declare function generateUniqueId(deviceName: string): string;
+/**
+ * Generates a unique ID based on four parameters.
+ *
+ * @param {string} param1 - The first parameter.
+ * @param {string} param2 - The second parameter.
+ * @param {string} param3 - The third parameter.
+ * @param {string} param4 - The fourth parameter.
+ * @returns {string} A unique ID generated from the concatenation of the parameters using MD5 hashing.
+ */
+export declare function createUniqueId(param1: string, param2: string, param3: string, param4: string): string;
+/**
+ * Retrieves the features for a specific behavior.
+ *
+ * @param {Endpoint} endpoint - The endpoint to retrieve the features from.
+ * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - The cluster to retrieve the features for.
+ *
+ * @returns {Record<string, boolean | undefined>} The features for the specified behavior.
+ *
+ * @remarks Use with:
+ * ```typescript
+ *     expect(featuresFor(device, 'powerSource').wired).toBe(true);
+ * ```
+ */
+export declare function featuresFor(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string): Record<string, boolean | undefined>;
+/**
+ * Maps a list of ClusterId to Behavior.Type for server clusters.
+ *
+ * @param {ClusterId[]} clusterServerList - The list of ClusterId to map.
+ * @returns {Behavior.Type[]} An array of Behavior.Type corresponding to the ClusterId in the server list.
+ */
+export declare function getBehaviourTypesFromClusterServerIds(clusterServerList: ClusterId[]): Behavior.Type[];
+/**
+ * Maps a list of ClusterId to Behavior.Type for client clusters.
+ *
+ * @param {ClusterId[]} clusterClientList - The list of ClusterId to map.
+ * @returns {Behavior.Type[]} An array of Behavior.Type corresponding to the ClusterId in the client list.
+ */
+export declare function getBehaviourTypesFromClusterClientIds(clusterClientList: ClusterId[]): Behavior.Type[];
+/**
+ * Maps a ClusterId to a Behavior.Type for server clusters.
+ *
+ * @param {ClusterId} clusterId - The ClusterId to map.
+ * @returns {Behavior.Type} The corresponding Behavior.Type for the given ClusterId.
+ */
+export declare function getBehaviourTypeFromClusterServerId(clusterId: ClusterId): Behavior.Type;
+/**
+ *  Maps a ClusterId to a Behavior.Type for client clusters.
+ *
+ * @param {ClusterId} _clusterId - The ClusterId to map.
+ */
+export declare function getBehaviourTypeFromClusterClientId(_clusterId: ClusterId): void;
+/**
+ *  Retrieves the Behavior.Type for a given cluster from the endpoint's supported behaviors.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to retrieve the behavior from.
+ * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - The cluster to retrieve the behavior for.
+ * @returns {Behavior.Type | undefined} The Behavior.Type for the given cluster, or undefined if not found.
+ */
+export declare function getBehavior(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string): Behavior.Type | undefined;
+/**
+ * Invokes a command on the specified behavior of the endpoint. Used ONLY in Jest tests.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to invoke the command on.
+ * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - The cluster to invoke the command on.
+ * @param {keyof MatterbridgeEndpointCommands} command - The command to invoke.
+ * @param {Record<string, boolean | number | bigint | string | object | null>} [params] - The parameters to pass to the command.
+ *
+ * @returns {Promise<boolean>} A promise that resolves to true if the command was invoked successfully, false otherwise.
+ *
+ * @deprecated Used ONLY in Jest tests.
+ */
+export declare function invokeBehaviorCommand(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, command: keyof MatterbridgeEndpointCommands, params?: Record<string, boolean | number | bigint | string | object | null>): Promise<boolean>;
+/**
+ * Invokes the subscription handler on the specified cluster and attribute of the endpoint. Used ONLY in Jest tests.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to invoke the subscription handler on.
+ * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - The cluster to invoke the subscription handler on.
+ * @param {string} attribute - The attribute to invoke the subscription handler on.
+ * @param {unknown} newValue - The new value of the attribute.
+ * @param {unknown} oldValue - The old value of the attribute.
+ *
+ * @returns {Promise<boolean>} A promise that resolves to true if the subscription handler was invoked successfully, false otherwise.
+ *
+ * @deprecated Used ONLY in Jest tests.
+ */
+export declare function invokeSubscribeHandler(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, newValue: unknown, oldValue: unknown): Promise<boolean>;
+/**
+ * Adds required cluster servers to the specified endpoint based on the device types.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to add the required cluster servers to.
+ * @returns {void}
+ */
+export declare function addRequiredClusterServers(endpoint: MatterbridgeEndpoint): void;
+/**
+ * Adds optional cluster servers to the specified endpoint based on the device types.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to add the optional cluster servers to.
+ * @returns {void}
+ */
+export declare function addOptionalClusterServers(endpoint: MatterbridgeEndpoint): void;
+/**
+ * Adds cluster servers to the specified endpoint based on the provided server list.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to add the cluster servers to.
+ * @param {ClusterId[]} serverList - The list of cluster IDs to add.
+ */
+export declare function addClusterServers(endpoint: MatterbridgeEndpoint, serverList: ClusterId[]): void;
+/**
+ * Adds a fixed label to the FixedLabel cluster. The FixedLabel cluster is created if it does not exist.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to add the cluster servers to.
+ * @param {string} label - The label to add. Max 16 characters.
+ * @param {string} value - The value of the label. Max 16 characters.
+ */
+export declare function addFixedLabel(endpoint: MatterbridgeEndpoint, label: string, value: string): Promise<void>;
+/**
+ * Adds a user label to the UserLabel cluster. The UserLabel cluster is created if it does not exist.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to add the cluster servers to.
+ * @param {string} label - The label to add. Max 16 characters.
+ * @param {string} value - The value of the label. Max 16 characters.
+ */
+export declare function addUserLabel(endpoint: MatterbridgeEndpoint, label: string, value: string): Promise<void>;
+/**
+ * Returns the options for a given behavior type.
+ *
+ * @param {T} type - The behavior type.
+ * @param {Behavior.Options<T>} options - The options for the behavior type.
+ * @returns {Behavior.Options<T>} The options for the behavior type.
+ */
+export declare function optionsFor<T extends Behavior.Type>(type: T, options: Behavior.Options<T>): Behavior.Options<T>;
+/**
+ * Retrieves the cluster ID.
+ *
+ * @param {Endpoint} endpoint - The endpoint to retrieve the cluster ID from.
+ * @param {ClusterId} cluster - The ID of the cluster.
+ * @returns {number | undefined} The ID of the cluster.
+ */
+export declare function getClusterId(endpoint: Endpoint, cluster: string): number | undefined;
+/**
+ * Retrieves the ID of an attribute from a cluster behavior.
+ *
+ * @param {Endpoint} endpoint - The endpoint to retrieve the attribute ID from.
+ * @param {string} cluster - The name of the cluster.
+ * @param {string} attribute - The name of the attribute.
+ * @returns {number | undefined} The ID of the attribute, or undefined if not found.
+ */
+export declare function getAttributeId(endpoint: Endpoint, cluster: string, attribute: string): number | undefined;
+/**
+ * Retrieves the value of the provided attribute from the given cluster.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to retrieve the attribute from.
+ * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - The cluster to retrieve the attribute from.
+ * @param {string} attribute - The name of the attribute to retrieve.
+ * @param {AnsiLogger} [log] - (Optional) The logger to use for logging the retrieve. Errors are logged to the endpoint logger.
+ * @returns {any} The value of the attribute, or undefined if the attribute is not found.
+ */
+export declare function getAttribute(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, log?: AnsiLogger): any;
+/**
+ * Sets the value of an attribute on a cluster server.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to set the attribute on.
+ * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - The cluster to set the attribute on.
+ * @param {string} attribute - The name of the attribute.
+ * @param {boolean | number | bigint | string | object | null} value - The value to set for the attribute.
+ * @param {AnsiLogger} [log] - (Optional) The logger to use for logging the set. Errors are logged to the endpoint logger.
+ * @returns {Promise<boolean>} - A promise that resolves to a boolean indicating whether the attribute was successfully set.
+ */
+export declare function setAttribute(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, value: boolean | number | bigint | string | object | null, log?: AnsiLogger): Promise<boolean>;
+/**
+ * Sets the value of an attribute on a cluster server.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to update the attribute on.
+ * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - The cluster to update the attribute on.
+ * @param {string} attribute - The name of the attribute.
+ * @param {boolean | number | bigint | string | object | null} value - The value to set for the attribute.
+ * @param {AnsiLogger} [log] - (Optional) The logger to use for logging the update. Errors are logged to the endpoint logger.
+ * @returns {Promise<boolean>} - A promise that resolves to a boolean indicating whether the attribute was successfully set.
+ */
+export declare function updateAttribute(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, value: boolean | number | bigint | string | object | null, log?: AnsiLogger): Promise<boolean>;
+/**
+ * Subscribes to the provided attribute on a cluster.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to subscribe the attribute to.
+ * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - The cluster to subscribe the attribute to.
+ * @param {string} attribute - The name of the attribute to subscribe to.
+ * @param {(newValue: any, oldValue: any, context: ActionContext) => void} listener - A callback function that will be called when the attribute value changes. When context.offline === true then the change is locally generated and not from the controller.
+ * @param {AnsiLogger} [log] - Optional logger for logging errors and information.
+ * @returns {boolean} - A boolean indicating whether the subscription was successful.
+ *
+ * @remarks The listener function (cannot be async) will receive three parameters:
+ * - `newValue`: The new value of the attribute.
+ * - `oldValue`: The old value of the attribute.
+ * - `context`: The action context, which includes information about the action that triggered the change. When context.offline === true then the change is locally generated and not from the controller.
+ */
+export declare function subscribeAttribute(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string, listener: (newValue: any, oldValue: any, context: ActionContext) => void, log?: AnsiLogger): Promise<boolean>;
+/**
+ * Triggers an event on the specified cluster.
+ *
+ * @param {MatterbridgeEndpoint} endpoint - The endpoint to trigger the event on.
+ * @param {Behavior.Type | ClusterType | ClusterId | string} cluster - The ID of the cluster.
+ * @param {string} event - The name of the event to trigger.
+ * @param {Record<string, boolean | number | bigint | string | object | undefined | null>} payload - The payload to pass to the event.
+ * @param {AnsiLogger} [log] - Optional logger for logging information.
+ *
+ * @returns {Promise<boolean>} - A promise that resolves to a boolean indicating whether the event was successfully triggered.
+ */
+export declare function triggerEvent(endpoint: MatterbridgeEndpoint, cluster: Behavior.Type | ClusterType | ClusterId | string, event: string, payload: Record<string, boolean | number | bigint | string | object | undefined | null>, log?: AnsiLogger): Promise<boolean>;
+/** Utility Cluster Helpers */
+/**
+ * Get the default power source wired cluster server options.
+ *
+ * @param {PowerSource.WiredCurrentType} wiredCurrentType - The type of wired current (default: PowerSource.WiredCurrentType.Ac)
+ * @returns {Behavior.Options<PowerSourceClusterServer>} The options for the power source wired cluster server.
+ *
+ * @remarks
+ * - order: The order of the power source is a persisted attribute that indicates the order in which the power sources are used.
+ * - description: The description of the power source is a fixed attribute that describes the power source type.
+ * - wiredCurrentType: The type of wired current is a fixed attribute that indicates the type of wired current used by the power source (AC or DC).
+ */
+export declare function getDefaultPowerSourceWiredClusterServer(wiredCurrentType?: PowerSource.WiredCurrentType): Partial<import("@matter/node").ClusterState.Type<import("@matter/types/cluster").ClusterComposer.WithFeatures<ClusterType.Of<{
+    readonly id: 47;
+    readonly name: "PowerSource";
+    readonly revision: 3;
+    readonly features: {
+        readonly wired: import("@matter/types").BitFlag;
+        readonly battery: import("@matter/types").BitFlag;
+        readonly rechargeable: import("@matter/types").BitFlag;
+        readonly replaceable: import("@matter/types").BitFlag;
+    };
+    readonly attributes: {
+        readonly status: import("@matter/types/cluster").Attribute<PowerSource.PowerSourceStatus, any>;
+        readonly order: import("@matter/types/cluster").Attribute<number, any>;
+        readonly description: import("@matter/types/cluster").FixedAttribute<string, any>;
+        readonly endpointList: import("@matter/types/cluster").Attribute<import("@matter/types/datatype").EndpointNumber[], any>;
+    };
+    readonly extensions: readonly [{
+        readonly flags: {
+            readonly wired: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly wiredAssessedInputVoltage: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly wiredAssessedInputFrequency: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly wiredCurrentType: import("@matter/types/cluster").FixedAttribute<PowerSource.WiredCurrentType, any>;
+                readonly wiredAssessedCurrent: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly wiredNominalVoltage: import("@matter/types/cluster").OptionalFixedAttribute<number, any>;
+                readonly wiredMaximumCurrent: import("@matter/types/cluster").OptionalFixedAttribute<number, any>;
+                readonly wiredPresent: import("@matter/types/cluster").OptionalAttribute<boolean, any>;
+                readonly activeWiredFaults: import("@matter/types/cluster").OptionalAttribute<PowerSource.WiredFault[], any>;
+            };
+            readonly events: {
+                readonly wiredFaultChange: import("@matter/types/cluster").OptionalEvent<import("@matter/types").TypeFromFields<{
+                    current: import("@matter/types").FieldType<PowerSource.WiredFault[]>;
+                    previous: import("@matter/types").FieldType<PowerSource.WiredFault[]>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly battery: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly batVoltage: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly batPercentRemaining: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly batTimeRemaining: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly batChargeLevel: import("@matter/types/cluster").Attribute<PowerSource.BatChargeLevel, any>;
+                readonly batReplacementNeeded: import("@matter/types/cluster").Attribute<boolean, any>;
+                readonly batReplaceability: import("@matter/types/cluster").FixedAttribute<PowerSource.BatReplaceability, any>;
+                readonly batPresent: import("@matter/types/cluster").OptionalAttribute<boolean, any>;
+                readonly activeBatFaults: import("@matter/types/cluster").OptionalAttribute<PowerSource.BatFault[], any>;
+            };
+            readonly events: {
+                readonly batFaultChange: import("@matter/types/cluster").OptionalEvent<import("@matter/types").TypeFromFields<{
+                    current: import("@matter/types").FieldType<PowerSource.BatFault[]>;
+                    previous: import("@matter/types").FieldType<PowerSource.BatFault[]>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly replaceable: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly batReplacementDescription: import("@matter/types/cluster").FixedAttribute<string, any>;
+                readonly batCommonDesignation: import("@matter/types/cluster").OptionalFixedAttribute<PowerSource.BatCommonDesignation, any>;
+                readonly batAnsiDesignation: import("@matter/types/cluster").OptionalFixedAttribute<string, any>;
+                readonly batIecDesignation: import("@matter/types/cluster").OptionalFixedAttribute<string, any>;
+                readonly batApprovedChemistry: import("@matter/types/cluster").OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any>;
+                readonly batQuantity: import("@matter/types/cluster").FixedAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly replaceable: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly batCapacity: import("@matter/types/cluster").OptionalFixedAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly rechargeable: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly batCapacity: import("@matter/types/cluster").OptionalFixedAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly rechargeable: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly batChargeState: import("@matter/types/cluster").Attribute<PowerSource.BatChargeState, any>;
+                readonly batTimeToFullCharge: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly batFunctionalWhileCharging: import("@matter/types/cluster").Attribute<boolean, any>;
+                readonly batChargingCurrent: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly activeBatChargeFaults: import("@matter/types/cluster").OptionalAttribute<PowerSource.BatChargeFault[], any>;
+            };
+            readonly events: {
+                readonly batChargeFaultChange: import("@matter/types/cluster").OptionalEvent<import("@matter/types").TypeFromFields<{
+                    current: import("@matter/types").FieldType<PowerSource.BatChargeFault[]>;
+                    previous: import("@matter/types").FieldType<PowerSource.BatChargeFault[]>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly rechargeable: true;
+            readonly battery: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly replaceable: true;
+            readonly battery: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly wired: true;
+            readonly battery: true;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly wired: false;
+            readonly battery: false;
+        };
+        readonly component: false;
+    }];
+}>, readonly [PowerSource.Feature.Wired]>, typeof MatterbridgePowerSourceServer>>;
+/**
+ * Get the default power source battery cluster server options.
+ *
+ * @param {null | number} batPercentRemaining - The remaining battery percentage (default: null). The attribute is in the range 0-200.
+ * @param {PowerSource.BatChargeLevel} batChargeLevel - The battery charge level (default: PowerSource.BatChargeLevel.Ok).
+ * @param {null | number} batVoltage - The battery voltage (default: null).
+ * @param {PowerSource.BatReplaceability} batReplaceability - The replaceability of the battery (default: PowerSource.BatReplaceability.Unspecified).
+ * @returns {Behavior.Options<PowerSourceClusterServer>} The options for the power source replaceable battery cluster server.
+ *
+ * @remarks
+ * - order: The order of the power source is a persisted attribute that indicates the order in which the power sources are used.
+ * - description: The description of the power source is a fixed attribute that describes the power source type.
+ * - batReplaceability: The replaceability of the battery is a fixed attribute that indicates whether the battery is user-replaceable or not.
+ */
+export declare function getDefaultPowerSourceBatteryClusterServer(batPercentRemaining?: null | number, batChargeLevel?: PowerSource.BatChargeLevel, batVoltage?: null | number, batReplaceability?: PowerSource.BatReplaceability): Partial<import("@matter/node").ClusterState.Type<import("@matter/types/cluster").ClusterComposer.WithFeatures<ClusterType.Of<{
+    readonly id: 47;
+    readonly name: "PowerSource";
+    readonly revision: 3;
+    readonly features: {
+        readonly wired: import("@matter/types").BitFlag;
+        readonly battery: import("@matter/types").BitFlag;
+        readonly rechargeable: import("@matter/types").BitFlag;
+        readonly replaceable: import("@matter/types").BitFlag;
+    };
+    readonly attributes: {
+        readonly status: import("@matter/types/cluster").Attribute<PowerSource.PowerSourceStatus, any>;
+        readonly order: import("@matter/types/cluster").Attribute<number, any>;
+        readonly description: import("@matter/types/cluster").FixedAttribute<string, any>;
+        readonly endpointList: import("@matter/types/cluster").Attribute<import("@matter/types/datatype").EndpointNumber[], any>;
+    };
+    readonly extensions: readonly [{
+        readonly flags: {
+            readonly wired: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly wiredAssessedInputVoltage: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly wiredAssessedInputFrequency: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly wiredCurrentType: import("@matter/types/cluster").FixedAttribute<PowerSource.WiredCurrentType, any>;
+                readonly wiredAssessedCurrent: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly wiredNominalVoltage: import("@matter/types/cluster").OptionalFixedAttribute<number, any>;
+                readonly wiredMaximumCurrent: import("@matter/types/cluster").OptionalFixedAttribute<number, any>;
+                readonly wiredPresent: import("@matter/types/cluster").OptionalAttribute<boolean, any>;
+                readonly activeWiredFaults: import("@matter/types/cluster").OptionalAttribute<PowerSource.WiredFault[], any>;
+            };
+            readonly events: {
+                readonly wiredFaultChange: import("@matter/types/cluster").OptionalEvent<import("@matter/types").TypeFromFields<{
+                    current: import("@matter/types").FieldType<PowerSource.WiredFault[]>;
+                    previous: import("@matter/types").FieldType<PowerSource.WiredFault[]>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly battery: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly batVoltage: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly batPercentRemaining: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly batTimeRemaining: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly batChargeLevel: import("@matter/types/cluster").Attribute<PowerSource.BatChargeLevel, any>;
+                readonly batReplacementNeeded: import("@matter/types/cluster").Attribute<boolean, any>;
+                readonly batReplaceability: import("@matter/types/cluster").FixedAttribute<PowerSource.BatReplaceability, any>;
+                readonly batPresent: import("@matter/types/cluster").OptionalAttribute<boolean, any>;
+                readonly activeBatFaults: import("@matter/types/cluster").OptionalAttribute<PowerSource.BatFault[], any>;
+            };
+            readonly events: {
+                readonly batFaultChange: import("@matter/types/cluster").OptionalEvent<import("@matter/types").TypeFromFields<{
+                    current: import("@matter/types").FieldType<PowerSource.BatFault[]>;
+                    previous: import("@matter/types").FieldType<PowerSource.BatFault[]>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly replaceable: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly batReplacementDescription: import("@matter/types/cluster").FixedAttribute<string, any>;
+                readonly batCommonDesignation: import("@matter/types/cluster").OptionalFixedAttribute<PowerSource.BatCommonDesignation, any>;
+                readonly batAnsiDesignation: import("@matter/types/cluster").OptionalFixedAttribute<string, any>;
+                readonly batIecDesignation: import("@matter/types/cluster").OptionalFixedAttribute<string, any>;
+                readonly batApprovedChemistry: import("@matter/types/cluster").OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any>;
+                readonly batQuantity: import("@matter/types/cluster").FixedAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly replaceable: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly batCapacity: import("@matter/types/cluster").OptionalFixedAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly rechargeable: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly batCapacity: import("@matter/types/cluster").OptionalFixedAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly rechargeable: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly batChargeState: import("@matter/types/cluster").Attribute<PowerSource.BatChargeState, any>;
+                readonly batTimeToFullCharge: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly batFunctionalWhileCharging: import("@matter/types/cluster").Attribute<boolean, any>;
+                readonly batChargingCurrent: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly activeBatChargeFaults: import("@matter/types/cluster").OptionalAttribute<PowerSource.BatChargeFault[], any>;
+            };
+            readonly events: {
+                readonly batChargeFaultChange: import("@matter/types/cluster").OptionalEvent<import("@matter/types").TypeFromFields<{
+                    current: import("@matter/types").FieldType<PowerSource.BatChargeFault[]>;
+                    previous: import("@matter/types").FieldType<PowerSource.BatChargeFault[]>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly rechargeable: true;
+            readonly battery: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly replaceable: true;
+            readonly battery: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly wired: true;
+            readonly battery: true;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly wired: false;
+            readonly battery: false;
+        };
+        readonly component: false;
+    }];
+}>, readonly [PowerSource.Feature.Battery]>, typeof MatterbridgePowerSourceServer>>;
+/**
+ * Get the default power source replaceable battery cluster server options.
+ *
+ * @param {number} batPercentRemaining - The remaining battery percentage (default: 100). The attribute is in the range 0-200.
+ * @param {PowerSource.BatChargeLevel} batChargeLevel - The battery charge level (default: PowerSource.BatChargeLevel.Ok).
+ * @param {number} batVoltage - The battery voltage (default: 1500).
+ * @param {string} batReplacementDescription - The description of the battery replacement (default: 'Battery type').
+ * @param {number} batQuantity - The quantity of the battery (default: 1).
+ * @param {PowerSource.BatReplaceability} batReplaceability - The replaceability of the battery (default: PowerSource.BatReplaceability.UserReplaceable).
+ * @returns {Behavior.Options<PowerSourceClusterServer>} The options for the power source replaceable battery cluster server.
+ *
+ * @remarks
+ * - order: The order of the power source is a persisted attribute that indicates the order in which the power sources are used.
+ * - description: The description of the power source is a fixed attribute that describes the power source type.
+ * - batReplaceability: The replaceability of the battery is a fixed attribute that indicates whether the battery is user-replaceable or not.
+ * - batReplacementDescription: The description of the battery replacement is a fixed attribute that describes the battery type.
+ * - batQuantity: The quantity of the battery is a fixed attribute that indicates how many batteries are present in the device.
+ */
+export declare function getDefaultPowerSourceReplaceableBatteryClusterServer(batPercentRemaining?: number, batChargeLevel?: PowerSource.BatChargeLevel, batVoltage?: number, batReplacementDescription?: string, batQuantity?: number, batReplaceability?: PowerSource.BatReplaceability): Partial<import("@matter/node").ClusterState.Type<import("@matter/types/cluster").ClusterComposer.WithFeatures<ClusterType.Of<{
+    readonly id: 47;
+    readonly name: "PowerSource";
+    readonly revision: 3;
+    readonly features: {
+        readonly wired: import("@matter/types").BitFlag;
+        readonly battery: import("@matter/types").BitFlag;
+        readonly rechargeable: import("@matter/types").BitFlag;
+        readonly replaceable: import("@matter/types").BitFlag;
+    };
+    readonly attributes: {
+        readonly status: import("@matter/types/cluster").Attribute<PowerSource.PowerSourceStatus, any>;
+        readonly order: import("@matter/types/cluster").Attribute<number, any>;
+        readonly description: import("@matter/types/cluster").FixedAttribute<string, any>;
+        readonly endpointList: import("@matter/types/cluster").Attribute<import("@matter/types/datatype").EndpointNumber[], any>;
+    };
+    readonly extensions: readonly [{
+        readonly flags: {
+            readonly wired: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly wiredAssessedInputVoltage: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly wiredAssessedInputFrequency: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly wiredCurrentType: import("@matter/types/cluster").FixedAttribute<PowerSource.WiredCurrentType, any>;
+                readonly wiredAssessedCurrent: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly wiredNominalVoltage: import("@matter/types/cluster").OptionalFixedAttribute<number, any>;
+                readonly wiredMaximumCurrent: import("@matter/types/cluster").OptionalFixedAttribute<number, any>;
+                readonly wiredPresent: import("@matter/types/cluster").OptionalAttribute<boolean, any>;
+                readonly activeWiredFaults: import("@matter/types/cluster").OptionalAttribute<PowerSource.WiredFault[], any>;
+            };
+            readonly events: {
+                readonly wiredFaultChange: import("@matter/types/cluster").OptionalEvent<import("@matter/types").TypeFromFields<{
+                    current: import("@matter/types").FieldType<PowerSource.WiredFault[]>;
+                    previous: import("@matter/types").FieldType<PowerSource.WiredFault[]>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly battery: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly batVoltage: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly batPercentRemaining: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly batTimeRemaining: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly batChargeLevel: import("@matter/types/cluster").Attribute<PowerSource.BatChargeLevel, any>;
+                readonly batReplacementNeeded: import("@matter/types/cluster").Attribute<boolean, any>;
+                readonly batReplaceability: import("@matter/types/cluster").FixedAttribute<PowerSource.BatReplaceability, any>;
+                readonly batPresent: import("@matter/types/cluster").OptionalAttribute<boolean, any>;
+                readonly activeBatFaults: import("@matter/types/cluster").OptionalAttribute<PowerSource.BatFault[], any>;
+            };
+            readonly events: {
+                readonly batFaultChange: import("@matter/types/cluster").OptionalEvent<import("@matter/types").TypeFromFields<{
+                    current: import("@matter/types").FieldType<PowerSource.BatFault[]>;
+                    previous: import("@matter/types").FieldType<PowerSource.BatFault[]>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly replaceable: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly batReplacementDescription: import("@matter/types/cluster").FixedAttribute<string, any>;
+                readonly batCommonDesignation: import("@matter/types/cluster").OptionalFixedAttribute<PowerSource.BatCommonDesignation, any>;
+                readonly batAnsiDesignation: import("@matter/types/cluster").OptionalFixedAttribute<string, any>;
+                readonly batIecDesignation: import("@matter/types/cluster").OptionalFixedAttribute<string, any>;
+                readonly batApprovedChemistry: import("@matter/types/cluster").OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any>;
+                readonly batQuantity: import("@matter/types/cluster").FixedAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly replaceable: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly batCapacity: import("@matter/types/cluster").OptionalFixedAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly rechargeable: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly batCapacity: import("@matter/types/cluster").OptionalFixedAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly rechargeable: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly batChargeState: import("@matter/types/cluster").Attribute<PowerSource.BatChargeState, any>;
+                readonly batTimeToFullCharge: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly batFunctionalWhileCharging: import("@matter/types/cluster").Attribute<boolean, any>;
+                readonly batChargingCurrent: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly activeBatChargeFaults: import("@matter/types/cluster").OptionalAttribute<PowerSource.BatChargeFault[], any>;
+            };
+            readonly events: {
+                readonly batChargeFaultChange: import("@matter/types/cluster").OptionalEvent<import("@matter/types").TypeFromFields<{
+                    current: import("@matter/types").FieldType<PowerSource.BatChargeFault[]>;
+                    previous: import("@matter/types").FieldType<PowerSource.BatChargeFault[]>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly rechargeable: true;
+            readonly battery: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly replaceable: true;
+            readonly battery: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly wired: true;
+            readonly battery: true;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly wired: false;
+            readonly battery: false;
+        };
+        readonly component: false;
+    }];
+}>, readonly [PowerSource.Feature.Battery, PowerSource.Feature.Replaceable]>, typeof MatterbridgePowerSourceServer>>;
+/**
+ * Creates a default power source rechargeable battery cluster server.
+ *
+ * @param {number} [batPercentRemaining] - The remaining battery percentage (default: 100). The attribute is in the range 0-200.
+ * @param {PowerSource.BatChargeLevel} [batChargeLevel] - The battery charge level (default: PowerSource.BatChargeLevel.Ok).
+ * @param {number} [batVoltage] - The battery voltage in mV (default: 1500).
+ * @param {PowerSource.BatReplaceability} [batReplaceability] - The replaceability of the battery (default: PowerSource.BatReplaceability.Unspecified).
+ * @returns {Behavior.Options<PowerSourceClusterServer>} The options for the power source rechargeable battery cluster server.
+ *
+ * @remarks
+ * - order: The order of the power source is a persisted attribute that indicates the order in which the power sources are used.
+ * - description: The description of the power source is a fixed attribute that describes the power source type.
+ * - batReplaceability: The replaceability of the battery is a fixed attribute that indicates whether the battery is user-replaceable or not.
+ */
+export declare function getDefaultPowerSourceRechargeableBatteryClusterServer(batPercentRemaining?: number, batChargeLevel?: PowerSource.BatChargeLevel, batVoltage?: number, batReplaceability?: PowerSource.BatReplaceability): Partial<import("@matter/node").ClusterState.Type<import("@matter/types/cluster").ClusterComposer.WithFeatures<ClusterType.Of<{
+    readonly id: 47;
+    readonly name: "PowerSource";
+    readonly revision: 3;
+    readonly features: {
+        readonly wired: import("@matter/types").BitFlag;
+        readonly battery: import("@matter/types").BitFlag;
+        readonly rechargeable: import("@matter/types").BitFlag;
+        readonly replaceable: import("@matter/types").BitFlag;
+    };
+    readonly attributes: {
+        readonly status: import("@matter/types/cluster").Attribute<PowerSource.PowerSourceStatus, any>;
+        readonly order: import("@matter/types/cluster").Attribute<number, any>;
+        readonly description: import("@matter/types/cluster").FixedAttribute<string, any>;
+        readonly endpointList: import("@matter/types/cluster").Attribute<import("@matter/types/datatype").EndpointNumber[], any>;
+    };
+    readonly extensions: readonly [{
+        readonly flags: {
+            readonly wired: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly wiredAssessedInputVoltage: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly wiredAssessedInputFrequency: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly wiredCurrentType: import("@matter/types/cluster").FixedAttribute<PowerSource.WiredCurrentType, any>;
+                readonly wiredAssessedCurrent: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly wiredNominalVoltage: import("@matter/types/cluster").OptionalFixedAttribute<number, any>;
+                readonly wiredMaximumCurrent: import("@matter/types/cluster").OptionalFixedAttribute<number, any>;
+                readonly wiredPresent: import("@matter/types/cluster").OptionalAttribute<boolean, any>;
+                readonly activeWiredFaults: import("@matter/types/cluster").OptionalAttribute<PowerSource.WiredFault[], any>;
+            };
+            readonly events: {
+                readonly wiredFaultChange: import("@matter/types/cluster").OptionalEvent<import("@matter/types").TypeFromFields<{
+                    current: import("@matter/types").FieldType<PowerSource.WiredFault[]>;
+                    previous: import("@matter/types").FieldType<PowerSource.WiredFault[]>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly battery: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly batVoltage: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly batPercentRemaining: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly batTimeRemaining: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly batChargeLevel: import("@matter/types/cluster").Attribute<PowerSource.BatChargeLevel, any>;
+                readonly batReplacementNeeded: import("@matter/types/cluster").Attribute<boolean, any>;
+                readonly batReplaceability: import("@matter/types/cluster").FixedAttribute<PowerSource.BatReplaceability, any>;
+                readonly batPresent: import("@matter/types/cluster").OptionalAttribute<boolean, any>;
+                readonly activeBatFaults: import("@matter/types/cluster").OptionalAttribute<PowerSource.BatFault[], any>;
+            };
+            readonly events: {
+                readonly batFaultChange: import("@matter/types/cluster").OptionalEvent<import("@matter/types").TypeFromFields<{
+                    current: import("@matter/types").FieldType<PowerSource.BatFault[]>;
+                    previous: import("@matter/types").FieldType<PowerSource.BatFault[]>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly replaceable: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly batReplacementDescription: import("@matter/types/cluster").FixedAttribute<string, any>;
+                readonly batCommonDesignation: import("@matter/types/cluster").OptionalFixedAttribute<PowerSource.BatCommonDesignation, any>;
+                readonly batAnsiDesignation: import("@matter/types/cluster").OptionalFixedAttribute<string, any>;
+                readonly batIecDesignation: import("@matter/types/cluster").OptionalFixedAttribute<string, any>;
+                readonly batApprovedChemistry: import("@matter/types/cluster").OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any>;
+                readonly batQuantity: import("@matter/types/cluster").FixedAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly replaceable: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly batCapacity: import("@matter/types/cluster").OptionalFixedAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly rechargeable: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly batCapacity: import("@matter/types/cluster").OptionalFixedAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly rechargeable: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly batChargeState: import("@matter/types/cluster").Attribute<PowerSource.BatChargeState, any>;
+                readonly batTimeToFullCharge: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly batFunctionalWhileCharging: import("@matter/types/cluster").Attribute<boolean, any>;
+                readonly batChargingCurrent: import("@matter/types/cluster").OptionalAttribute<number | null, any>;
+                readonly activeBatChargeFaults: import("@matter/types/cluster").OptionalAttribute<PowerSource.BatChargeFault[], any>;
+            };
+            readonly events: {
+                readonly batChargeFaultChange: import("@matter/types/cluster").OptionalEvent<import("@matter/types").TypeFromFields<{
+                    current: import("@matter/types").FieldType<PowerSource.BatChargeFault[]>;
+                    previous: import("@matter/types").FieldType<PowerSource.BatChargeFault[]>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly rechargeable: true;
+            readonly battery: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly replaceable: true;
+            readonly battery: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly wired: true;
+            readonly battery: true;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly wired: false;
+            readonly battery: false;
+        };
+        readonly component: false;
+    }];
+}>, readonly [PowerSource.Feature.Battery, PowerSource.Feature.Rechargeable]>, typeof MatterbridgePowerSourceServer>>;
+/**
+ * Get the default Electrical Energy Measurement Cluster Server options with features ImportedEnergy, ExportedEnergy, and CumulativeEnergy.
+ *
+ * @param {number} energyImported - The total consumption value in mW/h.
+ * @param {number} energyExported - The total production value in mW/h.
+ * @returns {Behavior.Options<ElectricalEnergyMeasurementServer>} - The default options for the Electrical Energy Measurement Cluster Server.
+ */
+export declare function getDefaultElectricalEnergyMeasurementClusterServer(energyImported?: number | bigint | null, energyExported?: number | bigint | null): Partial<import("@matter/node").ClusterState.Type<import("@matter/types/cluster").ClusterComposer.WithFeatures<ClusterType.Of<{
+    readonly id: 145;
+    readonly name: "ElectricalEnergyMeasurement";
+    readonly revision: 1;
+    readonly features: {
+        readonly importedEnergy: import("@matter/types").BitFlag;
+        readonly exportedEnergy: import("@matter/types").BitFlag;
+        readonly cumulativeEnergy: import("@matter/types").BitFlag;
+        readonly periodicEnergy: import("@matter/types").BitFlag;
+    };
+    readonly attributes: {
+        readonly accuracy: import("@matter/types/cluster").FixedAttribute<import("@matter/types").TypeFromFields<{
+            measurementType: import("@matter/types").FieldType<import("@matter/types").MeasurementType>;
+            measured: import("@matter/types").FieldType<boolean>;
+            minMeasuredValue: import("@matter/types").FieldType<number | bigint>;
+            maxMeasuredValue: import("@matter/types").FieldType<number | bigint>;
+            accuracyRanges: import("@matter/types").FieldType<import("@matter/types").TypeFromFields<{
+                rangeMin: import("@matter/types").FieldType<number | bigint>;
+                rangeMax: import("@matter/types").FieldType<number | bigint>;
+                percentMax: import("@matter/types").OptionalFieldType<number>;
+                percentMin: import("@matter/types").OptionalFieldType<number>;
+                percentTypical: import("@matter/types").OptionalFieldType<number>;
+                fixedMax: import("@matter/types").OptionalFieldType<number | bigint>;
+                fixedMin: import("@matter/types").OptionalFieldType<number | bigint>;
+                fixedTypical: import("@matter/types").OptionalFieldType<number | bigint>;
+            }>[]>;
+        }>, any>;
+    };
+    readonly extensions: readonly [{
+        readonly flags: {
+            readonly importedEnergy: true;
+            readonly cumulativeEnergy: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly cumulativeEnergyImported: import("@matter/types/cluster").Attribute<import("@matter/types").TypeFromFields<{
+                    energy: import("@matter/types").FieldType<number | bigint>;
+                    startTimestamp: import("@matter/types").OptionalFieldType<number>;
+                    endTimestamp: import("@matter/types").OptionalFieldType<number>;
+                    startSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                    endSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                }> | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly exportedEnergy: true;
+            readonly cumulativeEnergy: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly cumulativeEnergyExported: import("@matter/types/cluster").Attribute<import("@matter/types").TypeFromFields<{
+                    energy: import("@matter/types").FieldType<number | bigint>;
+                    startTimestamp: import("@matter/types").OptionalFieldType<number>;
+                    endTimestamp: import("@matter/types").OptionalFieldType<number>;
+                    startSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                    endSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                }> | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly importedEnergy: true;
+            readonly periodicEnergy: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly periodicEnergyImported: import("@matter/types/cluster").Attribute<import("@matter/types").TypeFromFields<{
+                    energy: import("@matter/types").FieldType<number | bigint>;
+                    startTimestamp: import("@matter/types").OptionalFieldType<number>;
+                    endTimestamp: import("@matter/types").OptionalFieldType<number>;
+                    startSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                    endSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                }> | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly exportedEnergy: true;
+            readonly periodicEnergy: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly periodicEnergyExported: import("@matter/types/cluster").Attribute<import("@matter/types").TypeFromFields<{
+                    energy: import("@matter/types").FieldType<number | bigint>;
+                    startTimestamp: import("@matter/types").OptionalFieldType<number>;
+                    endTimestamp: import("@matter/types").OptionalFieldType<number>;
+                    startSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                    endSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                }> | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly cumulativeEnergy: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly cumulativeEnergyReset: import("@matter/types/cluster").OptionalAttribute<import("@matter/types").TypeFromFields<{
+                    importedResetTimestamp: import("@matter/types").OptionalFieldType<number | null>;
+                    exportedResetTimestamp: import("@matter/types").OptionalFieldType<number | null>;
+                    importedResetSystime: import("@matter/types").OptionalFieldType<number | bigint | null>;
+                    exportedResetSystime: import("@matter/types").OptionalFieldType<number | bigint | null>;
+                }> | null, any>;
+            };
+            readonly events: {
+                readonly cumulativeEnergyMeasured: import("@matter/types/cluster").Event<import("@matter/types").TypeFromFields<{
+                    energyImported: import("@matter/types").OptionalFieldType<import("@matter/types").TypeFromFields<{
+                        energy: import("@matter/types").FieldType<number | bigint>;
+                        startTimestamp: import("@matter/types").OptionalFieldType<number>;
+                        endTimestamp: import("@matter/types").OptionalFieldType<number>;
+                        startSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                        endSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                    }>>;
+                    energyExported: import("@matter/types").OptionalFieldType<import("@matter/types").TypeFromFields<{
+                        energy: import("@matter/types").FieldType<number | bigint>;
+                        startTimestamp: import("@matter/types").OptionalFieldType<number>;
+                        endTimestamp: import("@matter/types").OptionalFieldType<number>;
+                        startSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                        endSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                    }>>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly periodicEnergy: true;
+        };
+        readonly component: {
+            readonly events: {
+                readonly periodicEnergyMeasured: import("@matter/types/cluster").Event<import("@matter/types").TypeFromFields<{
+                    energyImported: import("@matter/types").OptionalFieldType<import("@matter/types").TypeFromFields<{
+                        energy: import("@matter/types").FieldType<number | bigint>;
+                        startTimestamp: import("@matter/types").OptionalFieldType<number>;
+                        endTimestamp: import("@matter/types").OptionalFieldType<number>;
+                        startSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                        endSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                    }>>;
+                    energyExported: import("@matter/types").OptionalFieldType<import("@matter/types").TypeFromFields<{
+                        energy: import("@matter/types").FieldType<number | bigint>;
+                        startTimestamp: import("@matter/types").OptionalFieldType<number>;
+                        endTimestamp: import("@matter/types").OptionalFieldType<number>;
+                        startSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                        endSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                    }>>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly importedEnergy: false;
+            readonly exportedEnergy: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly cumulativeEnergy: false;
+            readonly periodicEnergy: false;
+        };
+        readonly component: false;
+    }];
+}>, readonly [ElectricalEnergyMeasurement.Feature.ImportedEnergy, ElectricalEnergyMeasurement.Feature.ExportedEnergy, ElectricalEnergyMeasurement.Feature.CumulativeEnergy]>, typeof ElectricalEnergyMeasurementServer>>;
+/**
+ * Get the default Electrical Power Measurement Cluster Server options with features AlternatingCurrent.
+ *
+ * @param {number} voltage - The voltage value in millivolts.
+ * @param {number} current - The current value in milliamperes.
+ * @param {number} power - The power value in milliwatts.
+ * @param {number} frequency - The frequency value in millihertz.
+ * @returns {Behavior.Options<ElectricalPowerMeasurementServer>} - The default options for the Electrical Power Measurement Cluster Server.
+ */
+export declare function getDefaultElectricalPowerMeasurementClusterServer(voltage?: number | bigint | null, current?: number | bigint | null, power?: number | bigint | null, frequency?: number | bigint | null): Partial<import("@matter/node").ClusterState.Type<import("@matter/types/cluster").ClusterComposer.WithFeatures<ClusterType.Of<{
+    readonly id: 144;
+    readonly name: "ElectricalPowerMeasurement";
+    readonly revision: 3;
+    readonly features: {
+        readonly directCurrent: import("@matter/types").BitFlag;
+        readonly alternatingCurrent: import("@matter/types").BitFlag;
+        readonly polyphasePower: import("@matter/types").BitFlag;
+        readonly harmonics: import("@matter/types").BitFlag;
+        readonly powerQuality: import("@matter/types").BitFlag;
+    };
+    readonly attributes: {
+        readonly powerMode: import("@matter/types/cluster").Attribute<ElectricalPowerMeasurement.PowerMode, any>;
+        readonly numberOfMeasurementTypes: import("@matter/types/cluster").FixedAttribute<number, any>;
+        readonly accuracy: import("@matter/types/cluster").FixedAttribute<import("@matter/types").TypeFromFields<{
+            measurementType: import("@matter/types").FieldType<import("@matter/types").MeasurementType>;
+            measured: import("@matter/types").FieldType<boolean>;
+            minMeasuredValue: import("@matter/types").FieldType<number | bigint>;
+            maxMeasuredValue: import("@matter/types").FieldType<number | bigint>;
+            accuracyRanges: import("@matter/types").FieldType<import("@matter/types").TypeFromFields<{
+                rangeMin: import("@matter/types").FieldType<number | bigint>;
+                rangeMax: import("@matter/types").FieldType<number | bigint>;
+                percentMax: import("@matter/types").OptionalFieldType<number>;
+                percentMin: import("@matter/types").OptionalFieldType<number>;
+                percentTypical: import("@matter/types").OptionalFieldType<number>;
+                fixedMax: import("@matter/types").OptionalFieldType<number | bigint>;
+                fixedMin: import("@matter/types").OptionalFieldType<number | bigint>;
+                fixedTypical: import("@matter/types").OptionalFieldType<number | bigint>;
+            }>[]>;
+        }>[], any>;
+        readonly ranges: import("@matter/types/cluster").OptionalAttribute<import("@matter/types").TypeFromFields<{
+            measurementType: import("@matter/types").FieldType<ElectricalPowerMeasurement.MeasurementType>;
+            min: import("@matter/types").FieldType<number | bigint>;
+            max: import("@matter/types").FieldType<number | bigint>;
+            startTimestamp: import("@matter/types").OptionalFieldType<number>;
+            endTimestamp: import("@matter/types").OptionalFieldType<number>;
+            minTimestamp: import("@matter/types").OptionalFieldType<number>;
+            maxTimestamp: import("@matter/types").OptionalFieldType<number>;
+            startSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+            endSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+            minSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+            maxSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+        }>[], any>;
+        readonly voltage: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+        readonly activeCurrent: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+        readonly activePower: import("@matter/types/cluster").Attribute<number | bigint | null, any>;
+    };
+    readonly events: {
+        readonly measurementPeriodRanges: import("@matter/types/cluster").OptionalEvent<import("@matter/types").TypeFromFields<{
+            ranges: import("@matter/types").FieldType<import("@matter/types").TypeFromFields<{
+                measurementType: import("@matter/types").FieldType<ElectricalPowerMeasurement.MeasurementType>;
+                min: import("@matter/types").FieldType<number | bigint>;
+                max: import("@matter/types").FieldType<number | bigint>;
+                startTimestamp: import("@matter/types").OptionalFieldType<number>;
+                endTimestamp: import("@matter/types").OptionalFieldType<number>;
+                minTimestamp: import("@matter/types").OptionalFieldType<number>;
+                maxTimestamp: import("@matter/types").OptionalFieldType<number>;
+                startSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                endSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                minSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                maxSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+            }>[]>;
+        }>, any>;
+    };
+    readonly extensions: readonly [{
+        readonly flags: {
+            readonly alternatingCurrent: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly reactiveCurrent: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+                readonly apparentCurrent: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+                readonly reactivePower: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+                readonly apparentPower: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+                readonly rmsVoltage: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+                readonly rmsCurrent: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+                readonly rmsPower: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+                readonly frequency: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+                readonly powerFactor: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly harmonics: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly harmonicCurrents: import("@matter/types/cluster").Attribute<import("@matter/types").TypeFromFields<{
+                    order: import("@matter/types").FieldType<number>;
+                    measurement: import("@matter/types").FieldType<number | bigint | null>;
+                }>[] | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly powerQuality: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly harmonicPhases: import("@matter/types/cluster").Attribute<import("@matter/types").TypeFromFields<{
+                    order: import("@matter/types").FieldType<number>;
+                    measurement: import("@matter/types").FieldType<number | bigint | null>;
+                }>[] | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly polyphasePower: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly neutralCurrent: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly polyphasePower: true;
+            readonly alternatingCurrent: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly harmonics: true;
+            readonly alternatingCurrent: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly powerQuality: true;
+            readonly alternatingCurrent: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly directCurrent: false;
+            readonly alternatingCurrent: false;
+        };
+        readonly component: false;
+    }];
+}>, readonly [ElectricalPowerMeasurement.Feature.AlternatingCurrent]>, typeof ElectricalPowerMeasurementServer>>;
+/**
+ * Get the default Electrical Apparent Power Measurement Cluster Server with features AlternatingCurrent.
+ *
+ * @param {number} voltage - The voltage value in millivolts.
+ * @param {number} apparentCurrent - The current value in milliamperes.
+ * @param {number} apparentPower - The apparent power value in millivoltamperes.
+ * @param {number} frequency - The frequency value in millihertz.
+ * @returns {Behavior.Options<ElectricalPowerMeasurementServer>} - The default options for the Electrical Apparent Power Measurement Cluster Server.
+ */
+export declare function getApparentElectricalPowerMeasurementClusterServer(voltage?: number | bigint | null, apparentCurrent?: number | bigint | null, apparentPower?: number | bigint | null, frequency?: number | bigint | null): Partial<import("@matter/node").ClusterState.Type<import("@matter/types/cluster").ClusterComposer.WithFeatures<ClusterType.Of<{
+    readonly id: 144;
+    readonly name: "ElectricalPowerMeasurement";
+    readonly revision: 3;
+    readonly features: {
+        readonly directCurrent: import("@matter/types").BitFlag;
+        readonly alternatingCurrent: import("@matter/types").BitFlag;
+        readonly polyphasePower: import("@matter/types").BitFlag;
+        readonly harmonics: import("@matter/types").BitFlag;
+        readonly powerQuality: import("@matter/types").BitFlag;
+    };
+    readonly attributes: {
+        readonly powerMode: import("@matter/types/cluster").Attribute<ElectricalPowerMeasurement.PowerMode, any>;
+        readonly numberOfMeasurementTypes: import("@matter/types/cluster").FixedAttribute<number, any>;
+        readonly accuracy: import("@matter/types/cluster").FixedAttribute<import("@matter/types").TypeFromFields<{
+            measurementType: import("@matter/types").FieldType<import("@matter/types").MeasurementType>;
+            measured: import("@matter/types").FieldType<boolean>;
+            minMeasuredValue: import("@matter/types").FieldType<number | bigint>;
+            maxMeasuredValue: import("@matter/types").FieldType<number | bigint>;
+            accuracyRanges: import("@matter/types").FieldType<import("@matter/types").TypeFromFields<{
+                rangeMin: import("@matter/types").FieldType<number | bigint>;
+                rangeMax: import("@matter/types").FieldType<number | bigint>;
+                percentMax: import("@matter/types").OptionalFieldType<number>;
+                percentMin: import("@matter/types").OptionalFieldType<number>;
+                percentTypical: import("@matter/types").OptionalFieldType<number>;
+                fixedMax: import("@matter/types").OptionalFieldType<number | bigint>;
+                fixedMin: import("@matter/types").OptionalFieldType<number | bigint>;
+                fixedTypical: import("@matter/types").OptionalFieldType<number | bigint>;
+            }>[]>;
+        }>[], any>;
+        readonly ranges: import("@matter/types/cluster").OptionalAttribute<import("@matter/types").TypeFromFields<{
+            measurementType: import("@matter/types").FieldType<ElectricalPowerMeasurement.MeasurementType>;
+            min: import("@matter/types").FieldType<number | bigint>;
+            max: import("@matter/types").FieldType<number | bigint>;
+            startTimestamp: import("@matter/types").OptionalFieldType<number>;
+            endTimestamp: import("@matter/types").OptionalFieldType<number>;
+            minTimestamp: import("@matter/types").OptionalFieldType<number>;
+            maxTimestamp: import("@matter/types").OptionalFieldType<number>;
+            startSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+            endSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+            minSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+            maxSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+        }>[], any>;
+        readonly voltage: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+        readonly activeCurrent: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+        readonly activePower: import("@matter/types/cluster").Attribute<number | bigint | null, any>;
+    };
+    readonly events: {
+        readonly measurementPeriodRanges: import("@matter/types/cluster").OptionalEvent<import("@matter/types").TypeFromFields<{
+            ranges: import("@matter/types").FieldType<import("@matter/types").TypeFromFields<{
+                measurementType: import("@matter/types").FieldType<ElectricalPowerMeasurement.MeasurementType>;
+                min: import("@matter/types").FieldType<number | bigint>;
+                max: import("@matter/types").FieldType<number | bigint>;
+                startTimestamp: import("@matter/types").OptionalFieldType<number>;
+                endTimestamp: import("@matter/types").OptionalFieldType<number>;
+                minTimestamp: import("@matter/types").OptionalFieldType<number>;
+                maxTimestamp: import("@matter/types").OptionalFieldType<number>;
+                startSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                endSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                minSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+                maxSystime: import("@matter/types").OptionalFieldType<number | bigint>;
+            }>[]>;
+        }>, any>;
+    };
+    readonly extensions: readonly [{
+        readonly flags: {
+            readonly alternatingCurrent: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly reactiveCurrent: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+                readonly apparentCurrent: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+                readonly reactivePower: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+                readonly apparentPower: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+                readonly rmsVoltage: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+                readonly rmsCurrent: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+                readonly rmsPower: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+                readonly frequency: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+                readonly powerFactor: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly harmonics: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly harmonicCurrents: import("@matter/types/cluster").Attribute<import("@matter/types").TypeFromFields<{
+                    order: import("@matter/types").FieldType<number>;
+                    measurement: import("@matter/types").FieldType<number | bigint | null>;
+                }>[] | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly powerQuality: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly harmonicPhases: import("@matter/types/cluster").Attribute<import("@matter/types").TypeFromFields<{
+                    order: import("@matter/types").FieldType<number>;
+                    measurement: import("@matter/types").FieldType<number | bigint | null>;
+                }>[] | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly polyphasePower: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly neutralCurrent: import("@matter/types/cluster").OptionalAttribute<number | bigint | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly polyphasePower: true;
+            readonly alternatingCurrent: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly harmonics: true;
+            readonly alternatingCurrent: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly powerQuality: true;
+            readonly alternatingCurrent: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly directCurrent: false;
+            readonly alternatingCurrent: false;
+        };
+        readonly component: false;
+    }];
+}>, readonly [ElectricalPowerMeasurement.Feature.AlternatingCurrent]>, typeof ElectricalPowerMeasurementServer>>;
+/**
+ * Get the default Device Energy Management Cluster Server with feature PowerForecastReporting and with the specified ESA type, ESA canGenerate, ESA state, and power limits.
+ *
+ * @param {DeviceEnergyManagement.EsaType} [esaType] - The ESA type. Defaults to `DeviceEnergyManagement.EsaType.Other`.
+ * @param {boolean} [esaCanGenerate] - Indicates if the ESA can generate energy. Defaults to `false`.
+ * @param {DeviceEnergyManagement.EsaState} [esaState] - The ESA state. Defaults to `DeviceEnergyManagement.EsaState.Online`.
+ * @param {number} [absMinPower] - Indicate the minimum electrical power in mw that the ESA can consume when switched on. Defaults to `0` if not provided.
+ * @param {number} [absMaxPower] - Indicate the maximum electrical power in mw that the ESA can consume when switched on. Defaults to `0` if not provided.
+ * @returns {Behavior.Options<DeviceEnergyManagementClusterServer>} - The default options for the Device Energy Management Cluster Server.
+ *
+ * @remarks
+ * - The forecast attribute is set to null, indicating that there is no forecast currently available.
+ * - The ESA type and canGenerate attributes are fixed and cannot be changed after creation.
+ * - The ESA state is set to Online by default.
+ * - The absolute minimum and maximum power attributes are set to 0 by default.
+ * - For example, a battery storage inverter that can charge its battery at a maximum power of 2000W and can
+ * discharge the battery at a maximum power of 3000W, would have a absMinPower: -3000W, absMaxPower: 2000W.
+ */
+export declare function getDefaultDeviceEnergyManagementClusterServer(esaType?: DeviceEnergyManagement.EsaType, esaCanGenerate?: boolean, esaState?: DeviceEnergyManagement.EsaState, absMinPower?: number, absMaxPower?: number): Partial<import("@matter/node").ClusterState.Type<import("@matter/types/cluster").ClusterComposer.WithFeatures<import("@matter/types/cluster").ClusterComposer.WithFeatures<ClusterType.Of<{
+    readonly id: 152;
+    readonly name: "DeviceEnergyManagement";
+    readonly revision: 4;
+    readonly features: {
+        readonly powerAdjustment: import("@matter/types").BitFlag;
+        readonly powerForecastReporting: import("@matter/types").BitFlag;
+        readonly stateForecastReporting: import("@matter/types").BitFlag;
+        readonly startTimeAdjustment: import("@matter/types").BitFlag;
+        readonly pausable: import("@matter/types").BitFlag;
+        readonly forecastAdjustment: import("@matter/types").BitFlag;
+        readonly constraintBasedAdjustment: import("@matter/types").BitFlag;
+    };
+    readonly attributes: {
+        readonly esaType: import("@matter/types/cluster").FixedAttribute<DeviceEnergyManagement.EsaType, any>;
+        readonly esaCanGenerate: import("@matter/types/cluster").FixedAttribute<boolean, any>;
+        readonly esaState: import("@matter/types/cluster").Attribute<DeviceEnergyManagement.EsaState, any>;
+        readonly absMinPower: import("@matter/types/cluster").Attribute<number | bigint, any>;
+        readonly absMaxPower: import("@matter/types/cluster").Attribute<number | bigint, any>;
+    };
+    readonly extensions: readonly [{
+        readonly flags: {
+            readonly powerAdjustment: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly powerAdjustmentCapability: import("@matter/types/cluster").Attribute<import("@matter/types").TypeFromFields<{
+                    powerAdjustCapability: import("@matter/types").FieldType<import("@matter/types").TypeFromFields<{
+                        minPower: import("@matter/types").FieldType<number | bigint>;
+                        maxPower: import("@matter/types").FieldType<number | bigint>;
+                        minDuration: import("@matter/types").FieldType<number>;
+                        maxDuration: import("@matter/types").FieldType<number>;
+                    }>[] | null>;
+                    cause: import("@matter/types").FieldType<DeviceEnergyManagement.PowerAdjustReason>;
+                }> | null, any>;
+            };
+            readonly commands: {
+                readonly powerAdjustRequest: import("@matter/types/cluster").Command<import("@matter/types").TypeFromFields<{
+                    power: import("@matter/types").FieldType<number | bigint>;
+                    duration: import("@matter/types").FieldType<number>;
+                    cause: import("@matter/types").FieldType<DeviceEnergyManagement.AdjustmentCause>;
+                }>, void, any>;
+                readonly cancelPowerAdjustRequest: import("@matter/types/cluster").Command<void, void, any>;
+            };
+            readonly events: {
+                readonly powerAdjustStart: import("@matter/types/cluster").Event<void, any>;
+                readonly powerAdjustEnd: import("@matter/types/cluster").Event<import("@matter/types").TypeFromFields<{
+                    cause: import("@matter/types").FieldType<DeviceEnergyManagement.Cause>;
+                    duration: import("@matter/types").FieldType<number>;
+                    energyUse: import("@matter/types").FieldType<number | bigint>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly powerForecastReporting: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly forecast: import("@matter/types/cluster").Attribute<import("@matter/types").TypeFromFields<{
+                    forecastId: import("@matter/types").FieldType<number>;
+                    activeSlotNumber: import("@matter/types").FieldType<number | null>;
+                    startTime: import("@matter/types").FieldType<number>;
+                    endTime: import("@matter/types").FieldType<number>;
+                    earliestStartTime: import("@matter/types").OptionalFieldType<number | null>;
+                    latestEndTime: import("@matter/types").OptionalFieldType<number>;
+                    isPausable: import("@matter/types").FieldType<boolean>;
+                    slots: import("@matter/types").FieldType<import("@matter/types").TypeFromFields<{
+                        minDuration: import("@matter/types").FieldType<number>;
+                        maxDuration: import("@matter/types").FieldType<number>;
+                        defaultDuration: import("@matter/types").FieldType<number>;
+                        elapsedSlotTime: import("@matter/types").FieldType<number>;
+                        remainingSlotTime: import("@matter/types").FieldType<number>;
+                        slotIsPausable: import("@matter/types").OptionalFieldType<boolean>;
+                        minPauseDuration: import("@matter/types").OptionalFieldType<number>;
+                        maxPauseDuration: import("@matter/types").OptionalFieldType<number>;
+                        manufacturerEsaState: import("@matter/types").OptionalFieldType<number>;
+                        nominalPower: import("@matter/types").OptionalFieldType<number | bigint>;
+                        minPower: import("@matter/types").OptionalFieldType<number | bigint>;
+                        maxPower: import("@matter/types").OptionalFieldType<number | bigint>;
+                        nominalEnergy: import("@matter/types").OptionalFieldType<number | bigint>;
+                        costs: import("@matter/types").OptionalFieldType<import("@matter/types").TypeFromFields<{
+                            costType: import("@matter/types").FieldType<DeviceEnergyManagement.CostType>;
+                            value: import("@matter/types").FieldType<number>;
+                            decimalPoints: import("@matter/types").FieldType<number>;
+                            currency: import("@matter/types").OptionalFieldType<number>;
+                        }>[]>;
+                        minPowerAdjustment: import("@matter/types").OptionalFieldType<number | bigint>;
+                        maxPowerAdjustment: import("@matter/types").OptionalFieldType<number | bigint>;
+                        minDurationAdjustment: import("@matter/types").OptionalFieldType<number>;
+                        maxDurationAdjustment: import("@matter/types").OptionalFieldType<number>;
+                    }>[]>;
+                    forecastUpdateReason: import("@matter/types").FieldType<DeviceEnergyManagement.ForecastUpdateReason>;
+                }> | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly stateForecastReporting: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly forecast: import("@matter/types/cluster").Attribute<import("@matter/types").TypeFromFields<{
+                    forecastId: import("@matter/types").FieldType<number>;
+                    activeSlotNumber: import("@matter/types").FieldType<number | null>;
+                    startTime: import("@matter/types").FieldType<number>;
+                    endTime: import("@matter/types").FieldType<number>;
+                    earliestStartTime: import("@matter/types").OptionalFieldType<number | null>;
+                    latestEndTime: import("@matter/types").OptionalFieldType<number>;
+                    isPausable: import("@matter/types").FieldType<boolean>;
+                    slots: import("@matter/types").FieldType<import("@matter/types").TypeFromFields<{
+                        minDuration: import("@matter/types").FieldType<number>;
+                        maxDuration: import("@matter/types").FieldType<number>;
+                        defaultDuration: import("@matter/types").FieldType<number>;
+                        elapsedSlotTime: import("@matter/types").FieldType<number>;
+                        remainingSlotTime: import("@matter/types").FieldType<number>;
+                        slotIsPausable: import("@matter/types").OptionalFieldType<boolean>;
+                        minPauseDuration: import("@matter/types").OptionalFieldType<number>;
+                        maxPauseDuration: import("@matter/types").OptionalFieldType<number>;
+                        manufacturerEsaState: import("@matter/types").OptionalFieldType<number>;
+                        nominalPower: import("@matter/types").OptionalFieldType<number | bigint>;
+                        minPower: import("@matter/types").OptionalFieldType<number | bigint>;
+                        maxPower: import("@matter/types").OptionalFieldType<number | bigint>;
+                        nominalEnergy: import("@matter/types").OptionalFieldType<number | bigint>;
+                        costs: import("@matter/types").OptionalFieldType<import("@matter/types").TypeFromFields<{
+                            costType: import("@matter/types").FieldType<DeviceEnergyManagement.CostType>;
+                            value: import("@matter/types").FieldType<number>;
+                            decimalPoints: import("@matter/types").FieldType<number>;
+                            currency: import("@matter/types").OptionalFieldType<number>;
+                        }>[]>;
+                        minPowerAdjustment: import("@matter/types").OptionalFieldType<number | bigint>;
+                        maxPowerAdjustment: import("@matter/types").OptionalFieldType<number | bigint>;
+                        minDurationAdjustment: import("@matter/types").OptionalFieldType<number>;
+                        maxDurationAdjustment: import("@matter/types").OptionalFieldType<number>;
+                    }>[]>;
+                    forecastUpdateReason: import("@matter/types").FieldType<DeviceEnergyManagement.ForecastUpdateReason>;
+                }> | null, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly powerAdjustment: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly optOutState: import("@matter/types/cluster").Attribute<DeviceEnergyManagement.OptOutState, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly startTimeAdjustment: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly optOutState: import("@matter/types/cluster").Attribute<DeviceEnergyManagement.OptOutState, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly pausable: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly optOutState: import("@matter/types/cluster").Attribute<DeviceEnergyManagement.OptOutState, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly forecastAdjustment: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly optOutState: import("@matter/types/cluster").Attribute<DeviceEnergyManagement.OptOutState, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly constraintBasedAdjustment: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly optOutState: import("@matter/types/cluster").Attribute<DeviceEnergyManagement.OptOutState, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly pausable: true;
+        };
+        readonly component: {
+            readonly commands: {
+                readonly pauseRequest: import("@matter/types/cluster").Command<import("@matter/types").TypeFromFields<{
+                    duration: import("@matter/types").FieldType<number>;
+                    cause: import("@matter/types").FieldType<DeviceEnergyManagement.AdjustmentCause>;
+                }>, void, any>;
+                readonly resumeRequest: import("@matter/types/cluster").Command<void, void, any>;
+            };
+            readonly events: {
+                readonly paused: import("@matter/types/cluster").Event<void, any>;
+                readonly resumed: import("@matter/types/cluster").Event<import("@matter/types").TypeFromFields<{
+                    cause: import("@matter/types").FieldType<DeviceEnergyManagement.Cause>;
+                }>, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly startTimeAdjustment: true;
+        };
+        readonly component: {
+            readonly commands: {
+                readonly startTimeAdjustRequest: import("@matter/types/cluster").Command<import("@matter/types").TypeFromFields<{
+                    requestedStartTime: import("@matter/types").FieldType<number>;
+                    cause: import("@matter/types").FieldType<DeviceEnergyManagement.AdjustmentCause>;
+                }>, void, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly forecastAdjustment: true;
+        };
+        readonly component: {
+            readonly commands: {
+                readonly modifyForecastRequest: import("@matter/types/cluster").Command<import("@matter/types").TypeFromFields<{
+                    forecastId: import("@matter/types").FieldType<number>;
+                    slotAdjustments: import("@matter/types").FieldType<import("@matter/types").TypeFromFields<{
+                        slotIndex: import("@matter/types").FieldType<number>;
+                        nominalPower: import("@matter/types").OptionalFieldType<number | bigint>;
+                        duration: import("@matter/types").FieldType<number>;
+                    }>[]>;
+                    cause: import("@matter/types").FieldType<DeviceEnergyManagement.AdjustmentCause>;
+                }>, void, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly constraintBasedAdjustment: true;
+        };
+        readonly component: {
+            readonly commands: {
+                readonly requestConstraintBasedForecast: import("@matter/types/cluster").Command<import("@matter/types").TypeFromFields<{
+                    constraints: import("@matter/types").FieldType<import("@matter/types").TypeFromFields<{
+                        startTime: import("@matter/types").FieldType<number>;
+                        duration: import("@matter/types").FieldType<number>;
+                        nominalPower: import("@matter/types").OptionalFieldType<number | bigint>;
+                        maximumEnergy: import("@matter/types").OptionalFieldType<number | bigint>;
+                        loadControl: import("@matter/types").OptionalFieldType<number>;
+                    }>[]>;
+                    cause: import("@matter/types").FieldType<DeviceEnergyManagement.AdjustmentCause>;
+                }>, void, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly startTimeAdjustment: true;
+        };
+        readonly component: {
+            readonly commands: {
+                readonly cancelRequest: import("@matter/types/cluster").Command<void, void, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly forecastAdjustment: true;
+        };
+        readonly component: {
+            readonly commands: {
+                readonly cancelRequest: import("@matter/types/cluster").Command<void, void, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly constraintBasedAdjustment: true;
+        };
+        readonly component: {
+            readonly commands: {
+                readonly cancelRequest: import("@matter/types/cluster").Command<void, void, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly staTrue: true;
+            readonly pauTrue: false;
+            readonly faTrue: false;
+            readonly conTrue: false;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly powerForecastReporting: true;
+            readonly stateForecastReporting: true;
+        };
+        readonly component: false;
+    }, {
+        readonly flags: {
+            readonly powerForecastReporting: false;
+            readonly stateForecastReporting: false;
+        };
+        readonly component: false;
+    }];
+}>, readonly [DeviceEnergyManagement.Feature.PowerForecastReporting, DeviceEnergyManagement.Feature.PowerAdjustment]>, readonly [DeviceEnergyManagement.Feature.PowerForecastReporting, DeviceEnergyManagement.Feature.PowerAdjustment]>, typeof MatterbridgeDeviceEnergyManagementServer>>;
+/**
+ * Get the default EnergyManagementMode Cluster Server.
+ *
+ * @param {number} [currentMode] - The current mode of the EnergyManagementMode cluster. Defaults to mode 1 (DeviceEnergyManagementMode.ModeTag.NoOptimization).
+ * @param {EnergyManagementMode.ModeOption[]} [supportedModes] - The supported modes for the DeviceEnergyManagementMode cluster. The attribute is fixed and defaults to a predefined set of cluster modes.
+ * @returns {Behavior.Options<DeviceEnergyManagementModeClusterServer>} - The default options for the Device Energy Management Mode cluster server.
+ *
+ * @remarks
+ * A few examples of Device Energy Management modes and their mode tags are provided below.
+ *  - For the "No Energy Management (Forecast reporting only)" mode, tags: 0x4000 (NoOptimization).
+ *  - For the "Device Energy Management" mode, tags: 0x4001 (DeviceOptimization).
+ *  - For the "Home Energy Management" mode, tags: 0x4001 (DeviceOptimization), 0x4002 (LocalOptimization).
+ *  - For the "Grid Energy Management" mode, tags: 0x4003 (GridOptimization).
+ *  - For the "Full Energy Management" mode, tags: 0x4001 (DeviceOptimization), 0x4002 (LocalOptimization), 0x4003 (GridOptimization).
+ */
+export declare function getDefaultDeviceEnergyManagementModeClusterServer(currentMode?: number, supportedModes?: DeviceEnergyManagementMode.ModeOption[]): Partial<import("@matter/node").ClusterState.Type<import("@matter/types/cluster").ClusterComposer.WithFeatures<DeviceEnergyManagementMode.Cluster, readonly []>, typeof MatterbridgeDeviceEnergyManagementModeServer>>;
+/** Application Cluster Helpers */
+/**
+ * Get the default OperationalState Cluster Server.
+ *
+ * @param {OperationalState.OperationalStateEnum} operationalState - The initial operational state id.
+ * @returns {Behavior.Options<MatterbridgeOperationalStateServer>} - The default options for the OperationalState cluster server.
+ *
+ * @remarks
+ * This method adds a cluster server with a default operational state configuration:
+ * - { operationalStateId: OperationalState.OperationalStateEnum.Stopped, operationalStateLabel: 'Stopped' },
+ * - { operationalStateId: OperationalState.OperationalStateEnum.Running, operationalStateLabel: 'Running' },
+ * - { operationalStateId: OperationalState.OperationalStateEnum.Paused, operationalStateLabel: 'Paused' },
+ * - { operationalStateId: OperationalState.OperationalStateEnum.Error, operationalStateLabel: 'Error' },
+ */
+export declare function getDefaultOperationalStateClusterServer(operationalState?: OperationalState.OperationalStateEnum): Partial<import("@matter/node").ClusterState.Type<import("@matter/types/cluster").ClusterComposer.WithFeatures<OperationalState.Cluster, readonly []>, typeof MatterbridgeOperationalStateServer>>;
+/**
+ * Get the default TemperatureMeasurement cluster server options.
+ *
+ * @param {number | null} measuredValue - The measured value of the temperature x 100.
+ * @param {number | null} minMeasuredValue - The minimum measured value of the temperature x 100.
+ * @param {number | null} maxMeasuredValue - The maximum measured value of the temperature x 100.
+ * @returns {Behavior.Options<MatterbridgeTemperatureMeasurementServer>} - The default options for the TemperatureMeasurement cluster server.
+ */
+export declare function getDefaultTemperatureMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): Partial<import("@matter/node").ClusterState.Type<TemperatureMeasurement.Cluster, typeof ClusterBehavior>>;
+/**
+ * Get the default RelativeHumidityMeasurement cluster server options.
+ *
+ * @param {number | null} measuredValue - The measured value of the relative humidity x 100.
+ * @param {number | null} minMeasuredValue - The minimum measured value of the relative humidity x 100.
+ * @param {number | null} maxMeasuredValue - The maximum measured value of the relative humidity x 100.
+ * @returns {Behavior.Options<MatterbridgeRelativeHumidityMeasurementServer>} - The default options for the RelativeHumidityMeasurement cluster server.
+ */
+export declare function getDefaultRelativeHumidityMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): Partial<import("@matter/node").ClusterState.Type<RelativeHumidityMeasurement.Cluster, typeof ClusterBehavior>>;
+/**
+ * Get the default PressureMeasurement cluster server options.
+ *
+ * @param {number | null} measuredValue - The measured value for the pressure in kPa x 10.
+ * @param {number | null} minMeasuredValue - The minimum measured value for the pressure in kPa x 10.
+ * @param {number | null} maxMeasuredValue - The maximum measured value for the pressure in kPa x 10.
+ * @returns {Behavior.Options<MatterbridgePressureMeasurementServer>} - The default options for the PressureMeasurement cluster server.
+ */
+export declare function getDefaultPressureMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): Partial<import("@matter/node").ClusterState.Type<PressureMeasurement.Cluster, typeof ClusterBehavior>>;
+/**
+ * Get the default IlluminanceMeasurement cluster server options.
+ *
+ * @param {number | null} measuredValue - The measured value of illuminance.
+ * @param {number | null} minMeasuredValue - The minimum measured value of illuminance.
+ * @param {number | null} maxMeasuredValue - The maximum measured value of illuminance.
+ * @returns {Behavior.Options<MatterbridgeIlluminanceMeasurementServer>} - The default options for the IlluminanceMeasurement cluster server.
+ *
+ * @remarks The default value for the illuminance measurement is null.
+ * This attribute SHALL indicate the illuminance in Lux (symbol lx) as follows:
+ * •  MeasuredValue = 10,000 x log10(illuminance) + 1,
+ *    where 1 lx <= illuminance <= 3.576 Mlx, corresponding to a MeasuredValue in the range 1 to 0xFFFE.
+ * • 0 indicates a value of illuminance that is too low to be measured
+ * • null indicates that the illuminance measurement is invalid.
+ */
+export declare function getDefaultIlluminanceMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): Partial<import("@matter/node").ClusterState.Type<IlluminanceMeasurement.Cluster, typeof ClusterBehavior>>;
+/**
+ * Get the default FlowMeasurement cluster server options.
+ *
+ * @param {number | null} measuredValue - The measured value of the flow in 10 x m3/h.
+ * @param {number | null} minMeasuredValue - The minimum measured value of the flow in 10 x m3/h.
+ * @param {number | null} maxMeasuredValue - The maximum measured value of the flow in 10 x m3/h.
+ * @returns {Behavior.Options<MatterbridgeFlowMeasurementServer>} - The default options for the FlowMeasurement cluster server.
+ */
+export declare function getDefaultFlowMeasurementClusterServer(measuredValue?: number | null, minMeasuredValue?: number | null, maxMeasuredValue?: number | null): Partial<import("@matter/node").ClusterState.Type<FlowMeasurement.Cluster, typeof ClusterBehavior>>;
+/**
+ * Get the default OccupancySensing cluster server options.
+ *
+ * @param {boolean} occupied - A boolean indicating whether the occupancy is occupied or not. Default is false.
+ * @param {number} holdTime - The hold time in seconds. Default is 30.
+ * @param {number} holdTimeMin - The minimum hold time in seconds. Default is 1.
+ * @param {number} holdTimeMax - The maximum hold time in seconds. Default is 300.
+ * @returns {Behavior.Options<MatterbridgeOccupancySensingServer>} - The default options for the OccupancySensing cluster server.
+ *
+ * @remarks The default value for the occupancy sensor type is PIR.
+ * Servers SHALL set these attributes for backward compatibility with clients implementing a cluster revision <= 4 as
+ * described in OccupancySensorType and OccupancySensorTypeBitmap Attributes.
+ * This replaces the 9 legacy attributes PIROccupiedToUnoccupiedDelay through PhysicalContactUnoccupiedToOccupiedThreshold.
+ */
+export declare function getDefaultOccupancySensingClusterServer(occupied?: boolean, holdTime?: number, holdTimeMin?: number, holdTimeMax?: number): Partial<import("@matter/node").ClusterState.Type<import("@matter/types/cluster").ClusterComposer.WithFeatures<ClusterType.Of<{
+    readonly id: 1030;
+    readonly name: "OccupancySensing";
+    readonly revision: 5;
+    readonly features: {
+        readonly other: import("@matter/types").BitFlag;
+        readonly passiveInfrared: import("@matter/types").BitFlag;
+        readonly ultrasonic: import("@matter/types").BitFlag;
+        readonly physicalContact: import("@matter/types").BitFlag;
+        readonly activeInfrared: import("@matter/types").BitFlag;
+        readonly radar: import("@matter/types").BitFlag;
+        readonly rfSensing: import("@matter/types").BitFlag;
+        readonly vision: import("@matter/types").BitFlag;
+    };
+    readonly attributes: {
+        readonly occupancy: import("@matter/types/cluster").Attribute<import("@matter/types").TypeFromPartialBitSchema<{
+            occupied: import("@matter/types").BitFlag;
+        }>, any>;
+        readonly occupancySensorType: import("@matter/types/cluster").FixedAttribute<OccupancySensing.OccupancySensorType, any>;
+        readonly occupancySensorTypeBitmap: import("@matter/types/cluster").FixedAttribute<import("@matter/types").TypeFromPartialBitSchema<{
+            pir: import("@matter/types").BitFlag;
+            ultrasonic: import("@matter/types").BitFlag;
+            physicalContact: import("@matter/types").BitFlag;
+        }>, any>;
+        readonly holdTime: import("@matter/types/cluster").OptionalWritableAttribute<number, any>;
+        readonly holdTimeLimits: import("@matter/types/cluster").OptionalFixedAttribute<import("@matter/types").TypeFromFields<{
+            holdTimeMin: import("@matter/types").FieldType<number>;
+            holdTimeMax: import("@matter/types").FieldType<number>;
+            holdTimeDefault: import("@matter/types").FieldType<number>;
+        }>, any>;
+    };
+    readonly events: {
+        readonly occupancyChanged: import("@matter/types/cluster").OptionalEvent<import("@matter/types").TypeFromFields<{
+            occupancy: import("@matter/types").FieldType<import("@matter/types").TypeFromPartialBitSchema<{
+                occupied: import("@matter/types").BitFlag;
+            }>>;
+        }>, any>;
+    };
+    readonly extensions: readonly [{
+        readonly flags: {
+            readonly passiveInfrared: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly pirOccupiedToUnoccupiedDelay: import("@matter/types/cluster").OptionalWritableAttribute<number, any>;
+                readonly pirUnoccupiedToOccupiedDelay: import("@matter/types/cluster").OptionalWritableAttribute<number, any>;
+                readonly pirUnoccupiedToOccupiedThreshold: import("@matter/types/cluster").OptionalWritableAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly ultrasonic: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly ultrasonicOccupiedToUnoccupiedDelay: import("@matter/types/cluster").OptionalWritableAttribute<number, any>;
+                readonly ultrasonicUnoccupiedToOccupiedDelay: import("@matter/types/cluster").OptionalWritableAttribute<number, any>;
+                readonly ultrasonicUnoccupiedToOccupiedThreshold: import("@matter/types/cluster").OptionalWritableAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly physicalContact: true;
+        };
+        readonly component: {
+            readonly attributes: {
+                readonly physicalContactOccupiedToUnoccupiedDelay: import("@matter/types/cluster").OptionalWritableAttribute<number, any>;
+                readonly physicalContactUnoccupiedToOccupiedDelay: import("@matter/types/cluster").OptionalWritableAttribute<number, any>;
+                readonly physicalContactUnoccupiedToOccupiedThreshold: import("@matter/types/cluster").OptionalWritableAttribute<number, any>;
+            };
+        };
+    }, {
+        readonly flags: {
+            readonly other: false;
+            readonly passiveInfrared: false;
+            readonly ultrasonic: false;
+            readonly physicalContact: false;
+            readonly activeInfrared: false;
+            readonly radar: false;
+            readonly rfSensing: false;
+            readonly vision: false;
+        };
+        readonly component: false;
+    }];
+}>, readonly [OccupancySensing.Feature.PassiveInfrared]>, typeof OccupancySensingServer>>;
+//# sourceMappingURL=matterbridgeEndpointHelpers.d.ts.map