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)

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;
}>>

Type declaration

  • ReadonlyacceptedCommandList: Attribute<CommandId[], never>

    List of client generated commands which are supported by this cluster server instance.

  • ReadonlyactiveBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            rechargeable: boolean;
        }];
    }
  • ReadonlyactiveBatFaults: OptionalAttribute<PowerSource.BatFault[], any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            battery: boolean;
        }];
    }
  • ReadonlyactiveWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            wired: boolean;
        }];
    }
  • ReadonlyattributeList: Attribute<AttributeId[], never>

    List of the attribute IDs of the attributes supported by the cluster instance.

  • ReadonlybatAnsiDesignation: OptionalFixedAttribute<string, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            replaceable: boolean;
        }];
    }
  • ReadonlybatApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            replaceable: boolean;
        }];
    }
  • ReadonlybatCapacity: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            replaceable: boolean;
        }, {
            rechargeable: boolean;
        }];
    }
  • ReadonlybatChargeLevel: Attribute<PowerSource.BatChargeLevel, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            battery: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlybatChargeState: Attribute<PowerSource.BatChargeState, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            rechargeable: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlybatChargingCurrent: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            rechargeable: boolean;
        }];
    }
  • ReadonlybatCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            replaceable: boolean;
        }];
    }
  • ReadonlybatFunctionalWhileCharging: Attribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            rechargeable: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlybatIecDesignation: OptionalFixedAttribute<string, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            replaceable: boolean;
        }];
    }
  • ReadonlybatPercentRemaining: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            battery: boolean;
        }];
    }
  • ReadonlybatPresent: OptionalAttribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            battery: boolean;
        }];
    }
  • ReadonlybatQuantity: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            replaceable: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlybatReplaceability: FixedAttribute<PowerSource.BatReplaceability, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            battery: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlybatReplacementDescription: FixedAttribute<string, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            replaceable: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlybatReplacementNeeded: Attribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            battery: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlybatTimeRemaining: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            battery: boolean;
        }];
    }
  • ReadonlybatTimeToFullCharge: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            rechargeable: boolean;
        }];
    }
  • ReadonlybatVoltage: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            battery: boolean;
        }];
    }
  • ReadonlyclusterRevision: Attribute<number, never>

    Indicates the revision of the server cluster specification supported by the cluster instance.

  • Readonlydescription: FixedAttribute<string, any>

    This attribute shall provide a user-facing description of this source, used to distinguish it from other power sources, e.g. "DC Power", "Primary Battery" or "Battery back-up". This attribute shall NOT be used to convey information such as battery form factor, or chemistry.

    See

    MatterSpecification.v13.Core § 11.7.7.3

  • ReadonlyendpointList: Attribute<EndpointNumber[], any>

    Indicates a list of endpoints that are powered by the source defined by this cluster. Multiple instances of this cluster may list the same endpoint, because it is possible for power for an endpoint to come from multiple sources. In that case the Order attribute indicates their priority.

    For each power source on a node, there shall only be one instance of this cluster.

    A cluster instance with an empty list shall indicate that the power source is for the entire node, which includes all endpoints.

    A cluster instance with a non-empty list shall include the endpoint, upon which the cluster instance resides.

    The above rules allow that some endpoints can have an unknown power source, and therefore would not be indicated by any instance of this cluster.

    Empty list examples

    Typically, there is one power source for the node. Also common is mains power for the node with battery backup power for the node. In both these common cases, for each cluster instance described, the list is empty.

    Populated list example

    A node has a mains power source with Order as 0 (zero), but some application endpoints (not all) have a battery back up source with Order as 1, which means this list is empty for the Power Source cluster associated with the mains power, because it indicates the entire node, but the Power Source cluster instance associated with the battery backup would list the endpoints that have a battery backup.

    See

    MatterSpecification.v13.Core § 11.7.7.32

  • ReadonlyfeatureMap: Attribute<TypeFromPartialBitSchema<{
        battery: BitFlag;
        rechargeable: BitFlag;
        replaceable: BitFlag;
        wired: BitFlag;
    }>, never>

    Indicates whether the server supports zero or more optional cluster features.

  • ReadonlygeneratedCommandList: Attribute<CommandId[], never>

    List of server generated commands (server to client commands).

  • Readonlyorder: Attribute<number, any>

    Indicates the relative preference with which the Node will select this source to provide power. A source with a lower order shall be selected by the Node to provide power before any other source with a higher order, if the lower order source is available (see Status).

    Note, Order is read-only and therefore NOT intended to allow clients control over power source selection.

    See

    MatterSpecification.v13.Core § 11.7.7.2

  • Readonlystatus: Attribute<PowerSource.PowerSourceStatus, any>

    Indicates the participation of this power source in providing power to the Node as specified in PowerSourceStatusEnum.

    See

    MatterSpecification.v13.Core § 11.7.7.1

  • ReadonlywiredAssessedCurrent: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            wired: boolean;
        }];
    }
  • ReadonlywiredAssessedInputFrequency: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            wired: boolean;
        }];
    }
  • ReadonlywiredAssessedInputVoltage: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            wired: boolean;
        }];
    }
  • ReadonlywiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            wired: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlywiredMaximumCurrent: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            wired: boolean;
        }];
    }
  • ReadonlywiredNominalVoltage: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            wired: boolean;
        }];
    }
  • ReadonlywiredPresent: OptionalAttribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            wired: boolean;
        }];
    }

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

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

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

    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>

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

    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>

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

    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>

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

    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>

Settings

Member Visibility

On This Page

Properties
Methods