/**
 * @license
 * Copyright 2022-2026 Matter.js Authors
 * SPDX-License-Identifier: Apache-2.0
 */
/*** THIS FILE IS GENERATED, DO NOT EDIT ***/
import { PowerSource } from "#clusters/power-source";
import { ClusterBehavior } from "../../behavior/cluster/ClusterBehavior.js";
import { ClusterType } from "#types";
import { Identity } from "#general";
/**
 * PowerSourceBehavior is the base class for objects that support interaction with {@link PowerSource.Cluster}.
 *
 * PowerSource.Cluster requires you to enable one or more optional features. You can do so using
 * {@link PowerSourceBehavior.with}.
 */
export declare const PowerSourceBehaviorConstructor: ClusterBehavior.Type<ClusterType.Of<{
    readonly id: 47;
    readonly name: "PowerSource";
    readonly revision: 3;
    readonly features: {
        readonly wired: import("#types").BitFlag;
        readonly battery: import("#types").BitFlag;
        readonly rechargeable: import("#types").BitFlag;
        readonly replaceable: import("#types").BitFlag;
    };
    readonly attributes: {
        readonly status: import("#types").Attribute<PowerSource.PowerSourceStatus, any>;
        readonly order: import("#types").Attribute<number, any>;
        readonly description: import("#types").FixedAttribute<string, any>;
        readonly endpointList: import("#types").Attribute<import("#types").EndpointNumber[], any>;
    };
    readonly extensions: readonly [{
        readonly flags: {
            readonly wired: true;
        };
        readonly component: {
            readonly attributes: {
                readonly wiredAssessedInputVoltage: import("#types").OptionalAttribute<number | null, any>;
                readonly wiredAssessedInputFrequency: import("#types").OptionalAttribute<number | null, any>;
                readonly wiredCurrentType: import("#types").FixedAttribute<PowerSource.WiredCurrentType, any>;
                readonly wiredAssessedCurrent: import("#types").OptionalAttribute<number | null, any>;
                readonly wiredNominalVoltage: import("#types").OptionalFixedAttribute<number, any>;
                readonly wiredMaximumCurrent: import("#types").OptionalFixedAttribute<number, any>;
                readonly wiredPresent: import("#types").OptionalAttribute<boolean, any>;
                readonly activeWiredFaults: import("#types").OptionalAttribute<PowerSource.WiredFault[], any>;
            };
            readonly events: {
                readonly wiredFaultChange: import("#types").OptionalEvent<import("#types").TypeFromFields<{
                    current: import("#types").FieldType<PowerSource.WiredFault[]>;
                    previous: import("#types").FieldType<PowerSource.WiredFault[]>;
                }>, any>;
            };
        };
    }, {
        readonly flags: {
            readonly battery: true;
        };
        readonly component: {
            readonly attributes: {
                readonly batVoltage: import("#types").OptionalAttribute<number | null, any>;
                readonly batPercentRemaining: import("#types").OptionalAttribute<number | null, any>;
                readonly batTimeRemaining: import("#types").OptionalAttribute<number | null, any>;
                readonly batChargeLevel: import("#types").Attribute<PowerSource.BatChargeLevel, any>;
                readonly batReplacementNeeded: import("#types").Attribute<boolean, any>;
                readonly batReplaceability: import("#types").FixedAttribute<PowerSource.BatReplaceability, any>;
                readonly batPresent: import("#types").OptionalAttribute<boolean, any>;
                readonly activeBatFaults: import("#types").OptionalAttribute<PowerSource.BatFault[], any>;
            };
            readonly events: {
                readonly batFaultChange: import("#types").OptionalEvent<import("#types").TypeFromFields<{
                    current: import("#types").FieldType<PowerSource.BatFault[]>;
                    previous: import("#types").FieldType<PowerSource.BatFault[]>;
                }>, any>;
            };
        };
    }, {
        readonly flags: {
            readonly replaceable: true;
        };
        readonly component: {
            readonly attributes: {
                readonly batReplacementDescription: import("#types").FixedAttribute<string, any>;
                readonly batCommonDesignation: import("#types").OptionalFixedAttribute<PowerSource.BatCommonDesignation, any>;
                readonly batAnsiDesignation: import("#types").OptionalFixedAttribute<string, any>;
                readonly batIecDesignation: import("#types").OptionalFixedAttribute<string, any>;
                readonly batApprovedChemistry: import("#types").OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any>;
                readonly batQuantity: import("#types").FixedAttribute<number, any>;
            };
        };
    }, {
        readonly flags: {
            readonly replaceable: true;
        };
        readonly component: {
            readonly attributes: {
                readonly batCapacity: import("#types").OptionalFixedAttribute<number, any>;
            };
        };
    }, {
        readonly flags: {
            readonly rechargeable: true;
        };
        readonly component: {
            readonly attributes: {
                readonly batCapacity: import("#types").OptionalFixedAttribute<number, any>;
            };
        };
    }, {
        readonly flags: {
            readonly rechargeable: true;
        };
        readonly component: {
            readonly attributes: {
                readonly batChargeState: import("#types").Attribute<PowerSource.BatChargeState, any>;
                readonly batTimeToFullCharge: import("#types").OptionalAttribute<number | null, any>;
                readonly batFunctionalWhileCharging: import("#types").Attribute<boolean, any>;
                readonly batChargingCurrent: import("#types").OptionalAttribute<number | null, any>;
                readonly activeBatChargeFaults: import("#types").OptionalAttribute<PowerSource.BatChargeFault[], any>;
            };
            readonly events: {
                readonly batChargeFaultChange: import("#types").OptionalEvent<import("#types").TypeFromFields<{
                    current: import("#types").FieldType<PowerSource.BatChargeFault[]>;
                    previous: import("#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;
    }];
}>, typeof ClusterBehavior, {
    components: never[];
}>;
export interface PowerSourceBehaviorConstructor extends Identity<typeof PowerSourceBehaviorConstructor> {
}
export declare const PowerSourceBehavior: PowerSourceBehaviorConstructor;
export interface PowerSourceBehavior extends InstanceType<PowerSourceBehaviorConstructor> {
}
export declare namespace PowerSourceBehavior {
    interface State extends InstanceType<typeof PowerSourceBehavior.State> {
    }
}
//# sourceMappingURL=PowerSourceBehavior.d.ts.map