Interface Complete

This cluster supports all PowerSource features. It may support illegal feature combinations.

If you use this cluster you must manually specify which features are active and ensure the set of active features is legal per the Matter specification.

interface Complete {
    attributes: Merge<{
        acceptedCommandList: Attribute<CommandId[], never>;
        activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        attributeList: Attribute<AttributeId[], never>;
        batAnsiDesignation: OptionalFixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batCapacity: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }, {
                rechargeable: boolean;
            }];
        };
        batChargeLevel: Attribute<PowerSource.BatChargeLevel, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batChargeState: Attribute<PowerSource.BatChargeState, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rechargeable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batChargingCurrent: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batFunctionalWhileCharging: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rechargeable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batIecDesignation: OptionalFixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batPercentRemaining: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batPresent: OptionalAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batQuantity: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                replaceable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplacementDescription: FixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                replaceable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplacementNeeded: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batTimeRemaining: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batTimeToFullCharge: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batVoltage: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        clusterRevision: Attribute<number, never>;
        description: FixedAttribute<string, any>;
        endpointList: Attribute<EndpointNumber[], any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        order: Attribute<number, any>;
        status: Attribute<PowerSource.PowerSourceStatus, any>;
        wiredAssessedCurrent: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredAssessedInputFrequency: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredAssessedInputVoltage: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                wired: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        wiredMaximumCurrent: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredNominalVoltage: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredPresent: OptionalAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
    }, GlobalAttributes<{
        battery: BitFlag;
        rechargeable: BitFlag;
        replaceable: BitFlag;
        wired: BitFlag;
    }>>;
    base: undefined;
    commands: {};
    events: {
        batChargeFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.BatChargeFault[]>;
            previous: FieldType<PowerSource.BatChargeFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.BatFault[]>;
            previous: FieldType<PowerSource.BatFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        wiredFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.WiredFault[]>;
            previous: FieldType<PowerSource.WiredFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
    };
    extensions: undefined;
    features: {
        battery: BitFlag;
        rechargeable: BitFlag;
        replaceable: BitFlag;
        wired: BitFlag;
    };
    id: Branded<Branded<47, "ClusterId">, "ClusterId">;
    name: "PowerSource";
    revision: 2;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rechargeable: boolean;
                }];
            };
            activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            attributeList: Attribute<AttributeId[], never>;
            batAnsiDesignation: OptionalFixedAttribute<string, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    replaceable: boolean;
                }];
            };
            batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    replaceable: boolean;
                }];
            };
            batCapacity: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    replaceable: boolean;
                }, {
                    rechargeable: boolean;
                }];
            };
            batChargeLevel: Attribute<PowerSource.BatChargeLevel, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    battery: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batChargeState: Attribute<PowerSource.BatChargeState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rechargeable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batChargingCurrent: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rechargeable: boolean;
                }];
            };
            batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    replaceable: boolean;
                }];
            };
            batFunctionalWhileCharging: Attribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rechargeable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batIecDesignation: OptionalFixedAttribute<string, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    replaceable: boolean;
                }];
            };
            batPercentRemaining: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            batPresent: OptionalAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            batQuantity: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    replaceable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    battery: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batReplacementDescription: FixedAttribute<string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    replaceable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batReplacementNeeded: Attribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    battery: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batTimeRemaining: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            batTimeToFullCharge: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rechargeable: boolean;
                }];
            };
            batVoltage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            clusterRevision: Attribute<number, never>;
            description: FixedAttribute<string, any>;
            endpointList: Attribute<EndpointNumber[], any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                battery: BitFlag;
                rechargeable: BitFlag;
                replaceable: BitFlag;
                wired: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            order: Attribute<number, any>;
            status: Attribute<PowerSource.PowerSourceStatus, any>;
            wiredAssessedCurrent: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            wiredAssessedInputFrequency: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            wiredAssessedInputVoltage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wired: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wiredMaximumCurrent: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            wiredNominalVoltage: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            wiredPresent: OptionalAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
        };
        events: {
            batChargeFaultChange: OptionalEvent<TypeFromFields<{
                current: FieldType<PowerSource.BatChargeFault[]>;
                previous: FieldType<PowerSource.BatChargeFault[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rechargeable: boolean;
                }];
            };
            batFaultChange: OptionalEvent<TypeFromFields<{
                current: FieldType<PowerSource.BatFault[]>;
                previous: FieldType<PowerSource.BatFault[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            wiredFaultChange: OptionalEvent<TypeFromFields<{
                current: FieldType<PowerSource.WiredFault[]>;
                previous: FieldType<PowerSource.WiredFault[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
        };
        features: {
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        };
        id: Branded<47, "ClusterId">;
        name: "PowerSource";
        revision: 2;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rechargeable: boolean;
                }];
            };
            activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            attributeList: Attribute<AttributeId[], never>;
            batAnsiDesignation: OptionalFixedAttribute<string, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    replaceable: boolean;
                }];
            };
            batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    replaceable: boolean;
                }];
            };
            batCapacity: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    replaceable: boolean;
                }, {
                    rechargeable: boolean;
                }];
            };
            batChargeLevel: Attribute<PowerSource.BatChargeLevel, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    battery: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batChargeState: Attribute<PowerSource.BatChargeState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rechargeable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batChargingCurrent: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rechargeable: boolean;
                }];
            };
            batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    replaceable: boolean;
                }];
            };
            batFunctionalWhileCharging: Attribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rechargeable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batIecDesignation: OptionalFixedAttribute<string, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    replaceable: boolean;
                }];
            };
            batPercentRemaining: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            batPresent: OptionalAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            batQuantity: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    replaceable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    battery: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batReplacementDescription: FixedAttribute<string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    replaceable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batReplacementNeeded: Attribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    battery: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batTimeRemaining: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            batTimeToFullCharge: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rechargeable: boolean;
                }];
            };
            batVoltage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            clusterRevision: Attribute<number, never>;
            description: FixedAttribute<string, any>;
            endpointList: Attribute<EndpointNumber[], any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                battery: BitFlag;
                rechargeable: BitFlag;
                replaceable: BitFlag;
                wired: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            order: Attribute<number, any>;
            status: Attribute<PowerSource.PowerSourceStatus, any>;
            wiredAssessedCurrent: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            wiredAssessedInputFrequency: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            wiredAssessedInputVoltage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wired: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wiredMaximumCurrent: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            wiredNominalVoltage: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            wiredPresent: OptionalAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
        };
        events: {
            batChargeFaultChange: OptionalEvent<TypeFromFields<{
                current: FieldType<PowerSource.BatChargeFault[]>;
                previous: FieldType<PowerSource.BatChargeFault[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rechargeable: boolean;
                }];
            };
            batFaultChange: OptionalEvent<TypeFromFields<{
                current: FieldType<PowerSource.BatFault[]>;
                previous: FieldType<PowerSource.BatFault[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            wiredFaultChange: OptionalEvent<TypeFromFields<{
                current: FieldType<PowerSource.WiredFault[]>;
                previous: FieldType<PowerSource.WiredFault[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
        };
        features: {
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        };
        id: Branded<47, "ClusterId">;
        name: "PowerSource";
        revision: 2;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rechargeable: boolean;
                }];
            };
            activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            attributeList: Attribute<AttributeId[], never>;
            batAnsiDesignation: OptionalFixedAttribute<string, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    replaceable: boolean;
                }];
            };
            batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    replaceable: boolean;
                }];
            };
            batCapacity: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    replaceable: boolean;
                }, {
                    rechargeable: boolean;
                }];
            };
            batChargeLevel: Attribute<PowerSource.BatChargeLevel, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    battery: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batChargeState: Attribute<PowerSource.BatChargeState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rechargeable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batChargingCurrent: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rechargeable: boolean;
                }];
            };
            batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    replaceable: boolean;
                }];
            };
            batFunctionalWhileCharging: Attribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rechargeable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batIecDesignation: OptionalFixedAttribute<string, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    replaceable: boolean;
                }];
            };
            batPercentRemaining: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            batPresent: OptionalAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            batQuantity: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    replaceable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    battery: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batReplacementDescription: FixedAttribute<string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    replaceable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batReplacementNeeded: Attribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    battery: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batTimeRemaining: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            batTimeToFullCharge: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rechargeable: boolean;
                }];
            };
            batVoltage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            clusterRevision: Attribute<number, never>;
            description: FixedAttribute<string, any>;
            endpointList: Attribute<EndpointNumber[], any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                battery: BitFlag;
                rechargeable: BitFlag;
                replaceable: BitFlag;
                wired: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            order: Attribute<number, any>;
            status: Attribute<PowerSource.PowerSourceStatus, any>;
            wiredAssessedCurrent: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            wiredAssessedInputFrequency: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            wiredAssessedInputVoltage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wired: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wiredMaximumCurrent: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            wiredNominalVoltage: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            wiredPresent: OptionalAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
        };
        events: {
            batChargeFaultChange: OptionalEvent<TypeFromFields<{
                current: FieldType<PowerSource.BatChargeFault[]>;
                previous: FieldType<PowerSource.BatChargeFault[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rechargeable: boolean;
                }];
            };
            batFaultChange: OptionalEvent<TypeFromFields<{
                current: FieldType<PowerSource.BatFault[]>;
                previous: FieldType<PowerSource.BatFault[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            wiredFaultChange: OptionalEvent<TypeFromFields<{
                current: FieldType<PowerSource.WiredFault[]>;
                previous: FieldType<PowerSource.WiredFault[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
        };
        features: {
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        };
        id: Branded<47, "ClusterId">;
        name: "PowerSource";
        revision: 2;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rechargeable: boolean;
                }];
            };
            activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            attributeList: Attribute<AttributeId[], never>;
            batAnsiDesignation: OptionalFixedAttribute<string, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    replaceable: boolean;
                }];
            };
            batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    replaceable: boolean;
                }];
            };
            batCapacity: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    replaceable: boolean;
                }, {
                    rechargeable: boolean;
                }];
            };
            batChargeLevel: Attribute<PowerSource.BatChargeLevel, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    battery: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batChargeState: Attribute<PowerSource.BatChargeState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rechargeable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batChargingCurrent: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rechargeable: boolean;
                }];
            };
            batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    replaceable: boolean;
                }];
            };
            batFunctionalWhileCharging: Attribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rechargeable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batIecDesignation: OptionalFixedAttribute<string, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    replaceable: boolean;
                }];
            };
            batPercentRemaining: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            batPresent: OptionalAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            batQuantity: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    replaceable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    battery: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batReplacementDescription: FixedAttribute<string, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    replaceable: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batReplacementNeeded: Attribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    battery: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            batTimeRemaining: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            batTimeToFullCharge: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rechargeable: boolean;
                }];
            };
            batVoltage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            clusterRevision: Attribute<number, never>;
            description: FixedAttribute<string, any>;
            endpointList: Attribute<EndpointNumber[], any>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                battery: BitFlag;
                rechargeable: BitFlag;
                replaceable: BitFlag;
                wired: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            order: Attribute<number, any>;
            status: Attribute<PowerSource.PowerSourceStatus, any>;
            wiredAssessedCurrent: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            wiredAssessedInputFrequency: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            wiredAssessedInputVoltage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    wired: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wiredMaximumCurrent: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            wiredNominalVoltage: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
            wiredPresent: OptionalAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
        };
        events: {
            batChargeFaultChange: OptionalEvent<TypeFromFields<{
                current: FieldType<PowerSource.BatChargeFault[]>;
                previous: FieldType<PowerSource.BatChargeFault[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    rechargeable: boolean;
                }];
            };
            batFaultChange: OptionalEvent<TypeFromFields<{
                current: FieldType<PowerSource.BatFault[]>;
                previous: FieldType<PowerSource.BatFault[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    battery: boolean;
                }];
            };
            wiredFaultChange: OptionalEvent<TypeFromFields<{
                current: FieldType<PowerSource.WiredFault[]>;
                previous: FieldType<PowerSource.WiredFault[]>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    wired: boolean;
                }];
            };
        };
        features: {
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        };
        id: Branded<47, "ClusterId">;
        name: "PowerSource";
        revision: 2;
    }>, SelectionT>;
}

Hierarchy (view full)

Identity<typeof PowerSource.CompleteInstance>
- Complete

Index

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    acceptedCommandList: Attribute<CommandId[], never>;
    activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            rechargeable: boolean;
        }];
    };
    activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            battery: boolean;
        }];
    };
    activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            wired: boolean;
        }];
    };
    attributeList: Attribute<AttributeId[], never>;
    batAnsiDesignation: OptionalFixedAttribute<string, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            replaceable: boolean;
        }];
    };
    batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            replaceable: boolean;
        }];
    };
    batCapacity: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            replaceable: boolean;
        }, {
            rechargeable: boolean;
        }];
    };
    batChargeLevel: Attribute<PowerSource.BatChargeLevel, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            battery: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    batChargeState: Attribute<PowerSource.BatChargeState, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            rechargeable: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    batChargingCurrent: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            rechargeable: boolean;
        }];
    };
    batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            replaceable: boolean;
        }];
    };
    batFunctionalWhileCharging: Attribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            rechargeable: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    batIecDesignation: OptionalFixedAttribute<string, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            replaceable: boolean;
        }];
    };
    batPercentRemaining: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            battery: boolean;
        }];
    };
    batPresent: OptionalAttribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            battery: boolean;
        }];
    };
    batQuantity: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            replaceable: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            battery: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    batReplacementDescription: FixedAttribute<string, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            replaceable: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    batReplacementNeeded: Attribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            battery: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    batTimeRemaining: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            battery: boolean;
        }];
    };
    batTimeToFullCharge: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            rechargeable: boolean;
        }];
    };
    batVoltage: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            battery: boolean;
        }];
    };
    clusterRevision: Attribute<number, never>;
    description: FixedAttribute<string, any>;
    endpointList: Attribute<EndpointNumber[], any>;
    featureMap: Attribute<TypeFromPartialBitSchema<{
        battery: BitFlag;
        rechargeable: BitFlag;
        replaceable: BitFlag;
        wired: BitFlag;
    }>, never>;
    generatedCommandList: Attribute<CommandId[], never>;
    order: Attribute<number, any>;
    status: Attribute<PowerSource.PowerSourceStatus, any>;
    wiredAssessedCurrent: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            wired: boolean;
        }];
    };
    wiredAssessedInputFrequency: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            wired: boolean;
        }];
    };
    wiredAssessedInputVoltage: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            wired: boolean;
        }];
    };
    wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            wired: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    wiredMaximumCurrent: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            wired: boolean;
        }];
    };
    wiredNominalVoltage: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            wired: boolean;
        }];
    };
    wiredPresent: OptionalAttribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            wired: boolean;
        }];
    };
}, GlobalAttributes<{
    battery: BitFlag;
    rechargeable: BitFlag;
    replaceable: BitFlag;
    wired: BitFlag;
}>>

base

base: undefined

commands

commands: {}

events

events: {
    batChargeFaultChange: OptionalEvent<TypeFromFields<{
        current: FieldType<PowerSource.BatChargeFault[]>;
        previous: FieldType<PowerSource.BatChargeFault[]>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            rechargeable: boolean;
        }];
    };
    batFaultChange: OptionalEvent<TypeFromFields<{
        current: FieldType<PowerSource.BatFault[]>;
        previous: FieldType<PowerSource.BatFault[]>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            battery: boolean;
        }];
    };
    wiredFaultChange: OptionalEvent<TypeFromFields<{
        current: FieldType<PowerSource.WiredFault[]>;
        previous: FieldType<PowerSource.WiredFault[]>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            wired: boolean;
        }];
    };
}

extensions

extensions: undefined

features

features: {
    battery: BitFlag;
    rechargeable: BitFlag;
    replaceable: BitFlag;
    wired: BitFlag;
}

Type declaration

Readonlybattery: BitFlag
Battery

A battery power source
Readonlyrechargeable: BitFlag
Rechargeable

A rechargeable battery power source
Readonlyreplaceable: BitFlag
Replaceable

A replaceable battery power source
Readonlywired: BitFlag
Wired

A wired power source

id

id: Branded<Branded<47, "ClusterId">, "ClusterId">

name

revision

supportedFeatures

supportedFeatures: {}

unknown

Methods

alter

alter<const AlterationsT>(alterations): WithAlterations<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        attributeList: Attribute<AttributeId[], never>;
        batAnsiDesignation: OptionalFixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batCapacity: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }, {
                rechargeable: boolean;
            }];
        };
        batChargeLevel: Attribute<PowerSource.BatChargeLevel, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batChargeState: Attribute<PowerSource.BatChargeState, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rechargeable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batChargingCurrent: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batFunctionalWhileCharging: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rechargeable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batIecDesignation: OptionalFixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batPercentRemaining: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batPresent: OptionalAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batQuantity: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                replaceable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplacementDescription: FixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                replaceable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplacementNeeded: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batTimeRemaining: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batTimeToFullCharge: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batVoltage: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        clusterRevision: Attribute<number, never>;
        description: FixedAttribute<string, any>;
        endpointList: Attribute<EndpointNumber[], any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        order: Attribute<number, any>;
        status: Attribute<PowerSource.PowerSourceStatus, any>;
        wiredAssessedCurrent: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredAssessedInputFrequency: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredAssessedInputVoltage: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                wired: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        wiredMaximumCurrent: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredNominalVoltage: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredPresent: OptionalAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
    };
    events: {
        batChargeFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.BatChargeFault[]>;
            previous: FieldType<PowerSource.BatChargeFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.BatFault[]>;
            previous: FieldType<PowerSource.BatFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        wiredFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.WiredFault[]>;
            previous: FieldType<PowerSource.WiredFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
    };
    features: {
        battery: BitFlag;
        rechargeable: BitFlag;
        replaceable: BitFlag;
        wired: BitFlag;
    };
    id: Branded<47, "ClusterId">;
    name: "PowerSource";
    revision: 2;
}>, AlterationsT>
Modify elements using ElementModifier.alter.
Type Parameters
- const AlterationsT extends Alterations<Of<{
      attributes: {
          acceptedCommandList: Attribute<CommandId[], never>;
          activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  rechargeable: boolean;
              }];
          };
          activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  battery: boolean;
              }];
          };
          activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
          attributeList: Attribute<AttributeId[], never>;
          batAnsiDesignation: OptionalFixedAttribute<string, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  replaceable: boolean;
              }];
          };
          batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  replaceable: boolean;
              }];
          };
          batCapacity: OptionalFixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  replaceable: boolean;
              }, {
                  rechargeable: boolean;
              }];
          };
          batChargeLevel: Attribute<PowerSource.BatChargeLevel, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  battery: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batChargeState: Attribute<PowerSource.BatChargeState, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  rechargeable: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batChargingCurrent: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  rechargeable: boolean;
              }];
          };
          batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  replaceable: boolean;
              }];
          };
          batFunctionalWhileCharging: Attribute<boolean, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  rechargeable: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batIecDesignation: OptionalFixedAttribute<string, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  replaceable: boolean;
              }];
          };
          batPercentRemaining: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  battery: boolean;
              }];
          };
          batPresent: OptionalAttribute<boolean, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  battery: boolean;
              }];
          };
          batQuantity: FixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  replaceable: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  battery: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batReplacementDescription: FixedAttribute<string, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  replaceable: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batReplacementNeeded: Attribute<boolean, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  battery: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batTimeRemaining: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  battery: boolean;
              }];
          };
          batTimeToFullCharge: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  rechargeable: boolean;
              }];
          };
          batVoltage: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  battery: boolean;
              }];
          };
          clusterRevision: Attribute<number, never>;
          description: FixedAttribute<string, any>;
          endpointList: Attribute<EndpointNumber[], any>;
          featureMap: Attribute<TypeFromPartialBitSchema<{
              battery: BitFlag;
              rechargeable: BitFlag;
              replaceable: BitFlag;
              wired: BitFlag;
          }>, never>;
          generatedCommandList: Attribute<CommandId[], never>;
          order: Attribute<number, any>;
          status: Attribute<PowerSource.PowerSourceStatus, any>;
          wiredAssessedCurrent: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
          wiredAssessedInputFrequency: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
          wiredAssessedInputVoltage: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
          wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  wired: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          wiredMaximumCurrent: OptionalFixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
          wiredNominalVoltage: OptionalFixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
          wiredPresent: OptionalAttribute<boolean, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
      };
      events: {
          batChargeFaultChange: OptionalEvent<TypeFromFields<{
              current: FieldType<PowerSource.BatChargeFault[]>;
              previous: FieldType<PowerSource.BatChargeFault[]>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  rechargeable: boolean;
              }];
          };
          batFaultChange: OptionalEvent<TypeFromFields<{
              current: FieldType<PowerSource.BatFault[]>;
              previous: FieldType<PowerSource.BatFault[]>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  battery: boolean;
              }];
          };
          wiredFaultChange: OptionalEvent<TypeFromFields<{
              current: FieldType<PowerSource.WiredFault[]>;
              previous: FieldType<PowerSource.WiredFault[]>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
      };
      features: {
          battery: BitFlag;
          rechargeable: BitFlag;
          replaceable: BitFlag;
          wired: BitFlag;
      };
      id: Branded<47, "ClusterId">;
      name: "PowerSource";
      revision: 2;
  }>>
Parameters
- alterations: AlterationsT
Returns WithAlterations<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        attributeList: Attribute<AttributeId[], never>;
        batAnsiDesignation: OptionalFixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batCapacity: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }, {
                rechargeable: boolean;
            }];
        };
        batChargeLevel: Attribute<PowerSource.BatChargeLevel, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batChargeState: Attribute<PowerSource.BatChargeState, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rechargeable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batChargingCurrent: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batFunctionalWhileCharging: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rechargeable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batIecDesignation: OptionalFixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batPercentRemaining: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batPresent: OptionalAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batQuantity: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                replaceable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplacementDescription: FixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                replaceable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplacementNeeded: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batTimeRemaining: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batTimeToFullCharge: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batVoltage: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        clusterRevision: Attribute<number, never>;
        description: FixedAttribute<string, any>;
        endpointList: Attribute<EndpointNumber[], any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        order: Attribute<number, any>;
        status: Attribute<PowerSource.PowerSourceStatus, any>;
        wiredAssessedCurrent: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredAssessedInputFrequency: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredAssessedInputVoltage: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                wired: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        wiredMaximumCurrent: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredNominalVoltage: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredPresent: OptionalAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
    };
    events: {
        batChargeFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.BatChargeFault[]>;
            previous: FieldType<PowerSource.BatChargeFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.BatFault[]>;
            previous: FieldType<PowerSource.BatFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        wiredFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.WiredFault[]>;
            previous: FieldType<PowerSource.WiredFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
    };
    features: {
        battery: BitFlag;
        rechargeable: BitFlag;
        replaceable: BitFlag;
        wired: BitFlag;
    };
    id: Branded<47, "ClusterId">;
    name: "PowerSource";
    revision: 2;
}>, AlterationsT>
Inherited from Identity.alter
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:37

enable

enable<const FlagsT>(flags): WithFlags<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        attributeList: Attribute<AttributeId[], never>;
        batAnsiDesignation: OptionalFixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batCapacity: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }, {
                rechargeable: boolean;
            }];
        };
        batChargeLevel: Attribute<PowerSource.BatChargeLevel, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batChargeState: Attribute<PowerSource.BatChargeState, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rechargeable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batChargingCurrent: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batFunctionalWhileCharging: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rechargeable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batIecDesignation: OptionalFixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batPercentRemaining: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batPresent: OptionalAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batQuantity: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                replaceable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplacementDescription: FixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                replaceable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplacementNeeded: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batTimeRemaining: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batTimeToFullCharge: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batVoltage: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        clusterRevision: Attribute<number, never>;
        description: FixedAttribute<string, any>;
        endpointList: Attribute<EndpointNumber[], any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        order: Attribute<number, any>;
        status: Attribute<PowerSource.PowerSourceStatus, any>;
        wiredAssessedCurrent: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredAssessedInputFrequency: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredAssessedInputVoltage: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                wired: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        wiredMaximumCurrent: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredNominalVoltage: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredPresent: OptionalAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
    };
    events: {
        batChargeFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.BatChargeFault[]>;
            previous: FieldType<PowerSource.BatChargeFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.BatFault[]>;
            previous: FieldType<PowerSource.BatFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        wiredFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.WiredFault[]>;
            previous: FieldType<PowerSource.WiredFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
    };
    features: {
        battery: BitFlag;
        rechargeable: BitFlag;
        replaceable: BitFlag;
        wired: BitFlag;
    };
    id: Branded<47, "ClusterId">;
    name: "PowerSource";
    revision: 2;
}>, FlagsT>
Modify elements using ElementModifier.enable.
Type Parameters
- const FlagsT extends ElementFlags<Of<{
      attributes: {
          acceptedCommandList: Attribute<CommandId[], never>;
          activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  rechargeable: boolean;
              }];
          };
          activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  battery: boolean;
              }];
          };
          activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
          attributeList: Attribute<AttributeId[], never>;
          batAnsiDesignation: OptionalFixedAttribute<string, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  replaceable: boolean;
              }];
          };
          batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  replaceable: boolean;
              }];
          };
          batCapacity: OptionalFixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  replaceable: boolean;
              }, {
                  rechargeable: boolean;
              }];
          };
          batChargeLevel: Attribute<PowerSource.BatChargeLevel, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  battery: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batChargeState: Attribute<PowerSource.BatChargeState, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  rechargeable: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batChargingCurrent: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  rechargeable: boolean;
              }];
          };
          batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  replaceable: boolean;
              }];
          };
          batFunctionalWhileCharging: Attribute<boolean, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  rechargeable: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batIecDesignation: OptionalFixedAttribute<string, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  replaceable: boolean;
              }];
          };
          batPercentRemaining: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  battery: boolean;
              }];
          };
          batPresent: OptionalAttribute<boolean, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  battery: boolean;
              }];
          };
          batQuantity: FixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  replaceable: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  battery: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batReplacementDescription: FixedAttribute<string, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  replaceable: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batReplacementNeeded: Attribute<boolean, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  battery: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batTimeRemaining: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  battery: boolean;
              }];
          };
          batTimeToFullCharge: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  rechargeable: boolean;
              }];
          };
          batVoltage: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  battery: boolean;
              }];
          };
          clusterRevision: Attribute<number, never>;
          description: FixedAttribute<string, any>;
          endpointList: Attribute<EndpointNumber[], any>;
          featureMap: Attribute<TypeFromPartialBitSchema<{
              battery: BitFlag;
              rechargeable: BitFlag;
              replaceable: BitFlag;
              wired: BitFlag;
          }>, never>;
          generatedCommandList: Attribute<CommandId[], never>;
          order: Attribute<number, any>;
          status: Attribute<PowerSource.PowerSourceStatus, any>;
          wiredAssessedCurrent: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
          wiredAssessedInputFrequency: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
          wiredAssessedInputVoltage: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
          wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  wired: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          wiredMaximumCurrent: OptionalFixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
          wiredNominalVoltage: OptionalFixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
          wiredPresent: OptionalAttribute<boolean, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
      };
      events: {
          batChargeFaultChange: OptionalEvent<TypeFromFields<{
              current: FieldType<PowerSource.BatChargeFault[]>;
              previous: FieldType<PowerSource.BatChargeFault[]>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  rechargeable: boolean;
              }];
          };
          batFaultChange: OptionalEvent<TypeFromFields<{
              current: FieldType<PowerSource.BatFault[]>;
              previous: FieldType<PowerSource.BatFault[]>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  battery: boolean;
              }];
          };
          wiredFaultChange: OptionalEvent<TypeFromFields<{
              current: FieldType<PowerSource.WiredFault[]>;
              previous: FieldType<PowerSource.WiredFault[]>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
      };
      features: {
          battery: BitFlag;
          rechargeable: BitFlag;
          replaceable: BitFlag;
          wired: BitFlag;
      };
      id: Branded<47, "ClusterId">;
      name: "PowerSource";
      revision: 2;
  }>>
Parameters
- flags: FlagsT
Returns WithFlags<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        attributeList: Attribute<AttributeId[], never>;
        batAnsiDesignation: OptionalFixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batCapacity: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }, {
                rechargeable: boolean;
            }];
        };
        batChargeLevel: Attribute<PowerSource.BatChargeLevel, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batChargeState: Attribute<PowerSource.BatChargeState, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rechargeable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batChargingCurrent: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batFunctionalWhileCharging: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rechargeable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batIecDesignation: OptionalFixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batPercentRemaining: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batPresent: OptionalAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batQuantity: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                replaceable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplacementDescription: FixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                replaceable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplacementNeeded: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batTimeRemaining: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batTimeToFullCharge: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batVoltage: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        clusterRevision: Attribute<number, never>;
        description: FixedAttribute<string, any>;
        endpointList: Attribute<EndpointNumber[], any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        order: Attribute<number, any>;
        status: Attribute<PowerSource.PowerSourceStatus, any>;
        wiredAssessedCurrent: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredAssessedInputFrequency: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredAssessedInputVoltage: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                wired: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        wiredMaximumCurrent: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredNominalVoltage: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredPresent: OptionalAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
    };
    events: {
        batChargeFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.BatChargeFault[]>;
            previous: FieldType<PowerSource.BatChargeFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.BatFault[]>;
            previous: FieldType<PowerSource.BatFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        wiredFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.WiredFault[]>;
            previous: FieldType<PowerSource.WiredFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
    };
    features: {
        battery: BitFlag;
        rechargeable: BitFlag;
        replaceable: BitFlag;
        wired: BitFlag;
    };
    id: Branded<47, "ClusterId">;
    name: "PowerSource";
    revision: 2;
}>, FlagsT>
Inherited from Identity.enable
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:45

set

set<const ValuesT>(values): WithValues<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        attributeList: Attribute<AttributeId[], never>;
        batAnsiDesignation: OptionalFixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batCapacity: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }, {
                rechargeable: boolean;
            }];
        };
        batChargeLevel: Attribute<PowerSource.BatChargeLevel, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batChargeState: Attribute<PowerSource.BatChargeState, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rechargeable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batChargingCurrent: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batFunctionalWhileCharging: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rechargeable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batIecDesignation: OptionalFixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batPercentRemaining: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batPresent: OptionalAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batQuantity: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                replaceable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplacementDescription: FixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                replaceable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplacementNeeded: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batTimeRemaining: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batTimeToFullCharge: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batVoltage: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        clusterRevision: Attribute<number, never>;
        description: FixedAttribute<string, any>;
        endpointList: Attribute<EndpointNumber[], any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        order: Attribute<number, any>;
        status: Attribute<PowerSource.PowerSourceStatus, any>;
        wiredAssessedCurrent: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredAssessedInputFrequency: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredAssessedInputVoltage: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                wired: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        wiredMaximumCurrent: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredNominalVoltage: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredPresent: OptionalAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
    };
    events: {
        batChargeFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.BatChargeFault[]>;
            previous: FieldType<PowerSource.BatChargeFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.BatFault[]>;
            previous: FieldType<PowerSource.BatFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        wiredFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.WiredFault[]>;
            previous: FieldType<PowerSource.WiredFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
    };
    features: {
        battery: BitFlag;
        rechargeable: BitFlag;
        replaceable: BitFlag;
        wired: BitFlag;
    };
    id: Branded<47, "ClusterId">;
    name: "PowerSource";
    revision: 2;
}>, ValuesT>
Modify elements using ElementModifier.set.
Type Parameters
- const ValuesT extends {
      activeBatChargeFaults?: number[];
      activeBatFaults?: number[];
      activeWiredFaults?: number[];
      batAnsiDesignation?: string;
      batApprovedChemistry?: number;
      batCapacity?: number;
      batChargeLevel?: number;
      batChargeState?: number;
      batChargingCurrent?: null | number;
      batCommonDesignation?: number;
      batFunctionalWhileCharging?: boolean;
      batIecDesignation?: string;
      batPercentRemaining?: null | number;
      batPresent?: boolean;
      batQuantity?: number;
      batReplaceability?: number;
      batReplacementDescription?: string;
      batReplacementNeeded?: boolean;
      batTimeRemaining?: null | number;
      batTimeToFullCharge?: null | number;
      batVoltage?: null | number;
      description: string;
      endpointList: number[];
      order: number;
      status: number;
      wiredAssessedCurrent?: null | number;
      wiredAssessedInputFrequency?: null | number;
      wiredAssessedInputVoltage?: null | number;
      wiredCurrentType?: number;
      wiredMaximumCurrent?: number;
      wiredNominalVoltage?: number;
      wiredPresent?: boolean;
  }
Parameters
- values: ValuesT
Returns WithValues<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        attributeList: Attribute<AttributeId[], never>;
        batAnsiDesignation: OptionalFixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batCapacity: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }, {
                rechargeable: boolean;
            }];
        };
        batChargeLevel: Attribute<PowerSource.BatChargeLevel, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batChargeState: Attribute<PowerSource.BatChargeState, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rechargeable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batChargingCurrent: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batFunctionalWhileCharging: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rechargeable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batIecDesignation: OptionalFixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batPercentRemaining: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batPresent: OptionalAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batQuantity: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                replaceable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplacementDescription: FixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                replaceable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplacementNeeded: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batTimeRemaining: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batTimeToFullCharge: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batVoltage: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        clusterRevision: Attribute<number, never>;
        description: FixedAttribute<string, any>;
        endpointList: Attribute<EndpointNumber[], any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        order: Attribute<number, any>;
        status: Attribute<PowerSource.PowerSourceStatus, any>;
        wiredAssessedCurrent: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredAssessedInputFrequency: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredAssessedInputVoltage: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                wired: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        wiredMaximumCurrent: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredNominalVoltage: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredPresent: OptionalAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
    };
    events: {
        batChargeFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.BatChargeFault[]>;
            previous: FieldType<PowerSource.BatChargeFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.BatFault[]>;
            previous: FieldType<PowerSource.BatFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        wiredFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.WiredFault[]>;
            previous: FieldType<PowerSource.WiredFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
    };
    features: {
        battery: BitFlag;
        rechargeable: BitFlag;
        replaceable: BitFlag;
        wired: BitFlag;
    };
    id: Branded<47, "ClusterId">;
    name: "PowerSource";
    revision: 2;
}>, ValuesT>
Inherited from Identity.set
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:41

with

with<const SelectionT>(...selection): Of<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        attributeList: Attribute<AttributeId[], never>;
        batAnsiDesignation: OptionalFixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batCapacity: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }, {
                rechargeable: boolean;
            }];
        };
        batChargeLevel: Attribute<PowerSource.BatChargeLevel, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batChargeState: Attribute<PowerSource.BatChargeState, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rechargeable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batChargingCurrent: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batFunctionalWhileCharging: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rechargeable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batIecDesignation: OptionalFixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batPercentRemaining: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batPresent: OptionalAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batQuantity: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                replaceable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplacementDescription: FixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                replaceable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplacementNeeded: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batTimeRemaining: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batTimeToFullCharge: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batVoltage: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        clusterRevision: Attribute<number, never>;
        description: FixedAttribute<string, any>;
        endpointList: Attribute<EndpointNumber[], any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        order: Attribute<number, any>;
        status: Attribute<PowerSource.PowerSourceStatus, any>;
        wiredAssessedCurrent: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredAssessedInputFrequency: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredAssessedInputVoltage: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                wired: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        wiredMaximumCurrent: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredNominalVoltage: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredPresent: OptionalAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
    };
    events: {
        batChargeFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.BatChargeFault[]>;
            previous: FieldType<PowerSource.BatChargeFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.BatFault[]>;
            previous: FieldType<PowerSource.BatFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        wiredFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.WiredFault[]>;
            previous: FieldType<PowerSource.WiredFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
    };
    features: {
        battery: BitFlag;
        rechargeable: BitFlag;
        replaceable: BitFlag;
        wired: BitFlag;
    };
    id: Branded<47, "ClusterId">;
    name: "PowerSource";
    revision: 2;
}>, SelectionT>
Select features using ClusterComposer.compose.
Type Parameters
- const SelectionT extends FeatureSelection<Of<{
      attributes: {
          acceptedCommandList: Attribute<CommandId[], never>;
          activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  rechargeable: boolean;
              }];
          };
          activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  battery: boolean;
              }];
          };
          activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
          attributeList: Attribute<AttributeId[], never>;
          batAnsiDesignation: OptionalFixedAttribute<string, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  replaceable: boolean;
              }];
          };
          batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  replaceable: boolean;
              }];
          };
          batCapacity: OptionalFixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  replaceable: boolean;
              }, {
                  rechargeable: boolean;
              }];
          };
          batChargeLevel: Attribute<PowerSource.BatChargeLevel, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  battery: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batChargeState: Attribute<PowerSource.BatChargeState, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  rechargeable: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batChargingCurrent: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  rechargeable: boolean;
              }];
          };
          batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  replaceable: boolean;
              }];
          };
          batFunctionalWhileCharging: Attribute<boolean, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  rechargeable: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batIecDesignation: OptionalFixedAttribute<string, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  replaceable: boolean;
              }];
          };
          batPercentRemaining: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  battery: boolean;
              }];
          };
          batPresent: OptionalAttribute<boolean, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  battery: boolean;
              }];
          };
          batQuantity: FixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  replaceable: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  battery: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batReplacementDescription: FixedAttribute<string, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  replaceable: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batReplacementNeeded: Attribute<boolean, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  battery: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          batTimeRemaining: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  battery: boolean;
              }];
          };
          batTimeToFullCharge: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  rechargeable: boolean;
              }];
          };
          batVoltage: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  battery: boolean;
              }];
          };
          clusterRevision: Attribute<number, never>;
          description: FixedAttribute<string, any>;
          endpointList: Attribute<EndpointNumber[], any>;
          featureMap: Attribute<TypeFromPartialBitSchema<{
              battery: BitFlag;
              rechargeable: BitFlag;
              replaceable: BitFlag;
              wired: BitFlag;
          }>, never>;
          generatedCommandList: Attribute<CommandId[], never>;
          order: Attribute<number, any>;
          status: Attribute<PowerSource.PowerSourceStatus, any>;
          wiredAssessedCurrent: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
          wiredAssessedInputFrequency: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
          wiredAssessedInputVoltage: OptionalAttribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
          wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  wired: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          wiredMaximumCurrent: OptionalFixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
          wiredNominalVoltage: OptionalFixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
          wiredPresent: OptionalAttribute<boolean, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
      };
      events: {
          batChargeFaultChange: OptionalEvent<TypeFromFields<{
              current: FieldType<PowerSource.BatChargeFault[]>;
              previous: FieldType<PowerSource.BatChargeFault[]>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  rechargeable: boolean;
              }];
          };
          batFaultChange: OptionalEvent<TypeFromFields<{
              current: FieldType<PowerSource.BatFault[]>;
              previous: FieldType<PowerSource.BatFault[]>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  battery: boolean;
              }];
          };
          wiredFaultChange: OptionalEvent<TypeFromFields<{
              current: FieldType<PowerSource.WiredFault[]>;
              previous: FieldType<PowerSource.WiredFault[]>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  wired: boolean;
              }];
          };
      };
      features: {
          battery: BitFlag;
          rechargeable: BitFlag;
          replaceable: BitFlag;
          wired: BitFlag;
      };
      id: Branded<47, "ClusterId">;
      name: "PowerSource";
      revision: 2;
  }>>
Parameters
- Rest...selection: SelectionT
Returns Of<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        attributeList: Attribute<AttributeId[], never>;
        batAnsiDesignation: OptionalFixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batCapacity: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }, {
                rechargeable: boolean;
            }];
        };
        batChargeLevel: Attribute<PowerSource.BatChargeLevel, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batChargeState: Attribute<PowerSource.BatChargeState, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rechargeable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batChargingCurrent: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batFunctionalWhileCharging: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rechargeable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batIecDesignation: OptionalFixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                replaceable: boolean;
            }];
        };
        batPercentRemaining: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batPresent: OptionalAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batQuantity: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                replaceable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplacementDescription: FixedAttribute<string, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                replaceable: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batReplacementNeeded: Attribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                battery: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        batTimeRemaining: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        batTimeToFullCharge: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batVoltage: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        clusterRevision: Attribute<number, never>;
        description: FixedAttribute<string, any>;
        endpointList: Attribute<EndpointNumber[], any>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        order: Attribute<number, any>;
        status: Attribute<PowerSource.PowerSourceStatus, any>;
        wiredAssessedCurrent: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredAssessedInputFrequency: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredAssessedInputVoltage: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                wired: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        wiredMaximumCurrent: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredNominalVoltage: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
        wiredPresent: OptionalAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
    };
    events: {
        batChargeFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.BatChargeFault[]>;
            previous: FieldType<PowerSource.BatChargeFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                rechargeable: boolean;
            }];
        };
        batFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.BatFault[]>;
            previous: FieldType<PowerSource.BatFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                battery: boolean;
            }];
        };
        wiredFaultChange: OptionalEvent<TypeFromFields<{
            current: FieldType<PowerSource.WiredFault[]>;
            previous: FieldType<PowerSource.WiredFault[]>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                wired: boolean;
            }];
        };
    };
    features: {
        battery: BitFlag;
        rechargeable: BitFlag;
        replaceable: BitFlag;
        wired: BitFlag;
    };
    id: Branded<47, "ClusterId">;
    name: "PowerSource";
    revision: 2;
}>, SelectionT>
Inherited from Identity.with
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:33

Interface Complete

Hierarchy (view full)

Index

Properties

Methods

Properties

attributes

base

commands

events

extensions

features

Type declaration

`Readonly`battery: BitFlag

`Readonly`rechargeable: BitFlag

`Readonly`replaceable: BitFlag

`Readonly`wired: BitFlag

id

name

revision

supportedFeatures

unknown

Methods

alter

Type Parameters

Parameters

enable

Type Parameters

Parameters

set

Type Parameters

Parameters

with

Type Parameters

Parameters

Settings

On This Page

Interface Complete

Hierarchy (view full)

Index

Properties

Methods

Properties

attributes

base

commands

events

extensions

features

Type declaration

Readonlybattery: BitFlag

Readonlyrechargeable: BitFlag

Readonlyreplaceable: BitFlag

Readonlywired: BitFlag

id

name

revision

supportedFeatures

unknown

Methods

alter

Type Parameters

Parameters

enable

Type Parameters

Parameters

set

Type Parameters

Parameters

with

Type Parameters

Parameters

Settings

On This Page

`Readonly`battery: BitFlag

`Readonly`rechargeable: BitFlag

`Readonly`replaceable: BitFlag

`Readonly`wired: BitFlag