Interface Cluster

This cluster is used to describe the configuration and capabilities of a physical power source that provides power to one or more endpoints on a node. In case the node has multiple power sources, each is described by its own cluster instance. Each instance of this cluster may be associated with one or more endpoints or the entire node.

PowerSourceCluster supports optional features that you can enable with the PowerSourceCluster.with() factory method.

See

MatterSpecification.v13.Core § 11.7

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

Type declaration

  • 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

  • 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

base

base: undefined

commands

commands: {}

events

events: {}

extensions

extensions: readonly [{
    component: {
        attributes: {
            activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any>;
            wiredAssessedCurrent: OptionalAttribute<null | number, any>;
            wiredAssessedInputFrequency: OptionalAttribute<null | number, any>;
            wiredAssessedInputVoltage: OptionalAttribute<null | number, any>;
            wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any>;
            wiredMaximumCurrent: OptionalFixedAttribute<number, any>;
            wiredNominalVoltage: OptionalFixedAttribute<number, any>;
            wiredPresent: OptionalAttribute<boolean, any>;
        };
        events: {
            wiredFaultChange: OptionalEvent<TypeFromFields<{
                current: FieldType<PowerSource.WiredFault[]>;
                previous: FieldType<PowerSource.WiredFault[]>;
            }>, any>;
        };
    };
    flags: {
        wired: true;
    };
}, {
    component: {
        attributes: {
            activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any>;
            batChargeLevel: Attribute<PowerSource.BatChargeLevel, any>;
            batPercentRemaining: OptionalAttribute<null | number, any>;
            batPresent: OptionalAttribute<boolean, any>;
            batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any>;
            batReplacementNeeded: Attribute<boolean, any>;
            batTimeRemaining: OptionalAttribute<null | number, any>;
            batVoltage: OptionalAttribute<null | number, any>;
        };
        events: {
            batFaultChange: OptionalEvent<TypeFromFields<{
                current: FieldType<PowerSource.BatFault[]>;
                previous: FieldType<PowerSource.BatFault[]>;
            }>, any>;
        };
    };
    flags: {
        battery: true;
    };
}, {
    component: {
        attributes: {
            batAnsiDesignation: OptionalFixedAttribute<string, any>;
            batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any>;
            batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any>;
            batIecDesignation: OptionalFixedAttribute<string, any>;
            batQuantity: FixedAttribute<number, any>;
            batReplacementDescription: FixedAttribute<string, any>;
        };
    };
    flags: {
        replaceable: true;
    };
}, {
    component: {
        attributes: {
            batCapacity: OptionalFixedAttribute<number, any>;
        };
    };
    flags: {
        replaceable: true;
    };
}, {
    component: {
        attributes: {
            batCapacity: OptionalFixedAttribute<number, any>;
        };
    };
    flags: {
        rechargeable: true;
    };
}, {
    component: {
        attributes: {
            activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any>;
            batChargeState: Attribute<PowerSource.BatChargeState, any>;
            batChargingCurrent: OptionalAttribute<null | number, any>;
            batFunctionalWhileCharging: Attribute<boolean, any>;
            batTimeToFullCharge: OptionalAttribute<null | number, any>;
        };
        events: {
            batChargeFaultChange: OptionalEvent<TypeFromFields<{
                current: FieldType<PowerSource.BatChargeFault[]>;
                previous: FieldType<PowerSource.BatChargeFault[]>;
            }>, any>;
        };
    };
    flags: {
        rechargeable: true;
    };
}, {
    component: false;
    flags: {
        battery: false;
        rechargeable: true;
    };
}, {
    component: false;
    flags: {
        battery: false;
        replaceable: true;
    };
}]

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<47, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            description: FixedAttribute<string, any>;
            endpointList: Attribute<EndpointNumber[], any>;
            order: Attribute<number, any>;
            status: Attribute<PowerSource.PowerSourceStatus, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any>;
                    wiredAssessedCurrent: OptionalAttribute<null | number, any>;
                    wiredAssessedInputFrequency: OptionalAttribute<null | number, any>;
                    wiredAssessedInputVoltage: OptionalAttribute<null | number, any>;
                    wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any>;
                    wiredMaximumCurrent: OptionalFixedAttribute<number, any>;
                    wiredNominalVoltage: OptionalFixedAttribute<number, any>;
                    wiredPresent: OptionalAttribute<boolean, any>;
                };
                events: {
                    wiredFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                wired: true;
            };
        }, {
            component: {
                attributes: {
                    activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any>;
                    batChargeLevel: Attribute<PowerSource.BatChargeLevel, any>;
                    batPercentRemaining: OptionalAttribute<null | number, any>;
                    batPresent: OptionalAttribute<boolean, any>;
                    batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any>;
                    batReplacementNeeded: Attribute<boolean, any>;
                    batTimeRemaining: OptionalAttribute<null | number, any>;
                    batVoltage: OptionalAttribute<null | number, any>;
                };
                events: {
                    batFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                battery: true;
            };
        }, {
            component: {
                attributes: {
                    batAnsiDesignation: OptionalFixedAttribute<string, any>;
                    batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any>;
                    batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any>;
                    batIecDesignation: OptionalFixedAttribute<string, any>;
                    batQuantity: FixedAttribute<number, any>;
                    batReplacementDescription: FixedAttribute<string, any>;
                };
            };
            flags: {
                replaceable: true;
            };
        }, {
            component: {
                attributes: {
                    batCapacity: OptionalFixedAttribute<number, any>;
                };
            };
            flags: {
                replaceable: true;
            };
        }, {
            component: {
                attributes: {
                    batCapacity: OptionalFixedAttribute<number, any>;
                };
            };
            flags: {
                rechargeable: true;
            };
        }, {
            component: {
                attributes: {
                    activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any>;
                    batChargeState: Attribute<PowerSource.BatChargeState, any>;
                    batChargingCurrent: OptionalAttribute<null | number, any>;
                    batFunctionalWhileCharging: Attribute<boolean, any>;
                    batTimeToFullCharge: OptionalAttribute<null | number, any>;
                };
                events: {
                    batChargeFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                rechargeable: true;
            };
        }, {
            component: false;
            flags: {
                battery: false;
                rechargeable: true;
            };
        }, {
            component: false;
            flags: {
                battery: false;
                replaceable: true;
            };
        }];
        features: {
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        };
        id: 47;
        name: "PowerSource";
        revision: 2;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              description: FixedAttribute<string, any>;
              endpointList: Attribute<EndpointNumber[], any>;
              order: Attribute<number, any>;
              status: Attribute<PowerSource.PowerSourceStatus, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any>;
                      wiredAssessedCurrent: OptionalAttribute<null | number, any>;
                      wiredAssessedInputFrequency: OptionalAttribute<null | number, any>;
                      wiredAssessedInputVoltage: OptionalAttribute<null | number, any>;
                      wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any>;
                      wiredMaximumCurrent: OptionalFixedAttribute<number, any>;
                      wiredNominalVoltage: OptionalFixedAttribute<number, any>;
                      wiredPresent: OptionalAttribute<boolean, any>;
                  };
                  events: {
                      wiredFaultChange: OptionalEvent<TypeFromFields<{
                          current: FieldType<(...)>;
                          previous: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  wired: true;
              };
          }, {
              component: {
                  attributes: {
                      activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any>;
                      batChargeLevel: Attribute<PowerSource.BatChargeLevel, any>;
                      batPercentRemaining: OptionalAttribute<null | number, any>;
                      batPresent: OptionalAttribute<boolean, any>;
                      batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any>;
                      batReplacementNeeded: Attribute<boolean, any>;
                      batTimeRemaining: OptionalAttribute<null | number, any>;
                      batVoltage: OptionalAttribute<null | number, any>;
                  };
                  events: {
                      batFaultChange: OptionalEvent<TypeFromFields<{
                          current: FieldType<(...)>;
                          previous: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  battery: true;
              };
          }, {
              component: {
                  attributes: {
                      batAnsiDesignation: OptionalFixedAttribute<string, any>;
                      batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any>;
                      batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any>;
                      batIecDesignation: OptionalFixedAttribute<string, any>;
                      batQuantity: FixedAttribute<number, any>;
                      batReplacementDescription: FixedAttribute<string, any>;
                  };
              };
              flags: {
                  replaceable: true;
              };
          }, {
              component: {
                  attributes: {
                      batCapacity: OptionalFixedAttribute<number, any>;
                  };
              };
              flags: {
                  replaceable: true;
              };
          }, {
              component: {
                  attributes: {
                      batCapacity: OptionalFixedAttribute<number, any>;
                  };
              };
              flags: {
                  rechargeable: true;
              };
          }, {
              component: {
                  attributes: {
                      activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any>;
                      batChargeState: Attribute<PowerSource.BatChargeState, any>;
                      batChargingCurrent: OptionalAttribute<null | number, any>;
                      batFunctionalWhileCharging: Attribute<boolean, any>;
                      batTimeToFullCharge: OptionalAttribute<null | number, any>;
                  };
                  events: {
                      batChargeFaultChange: OptionalEvent<TypeFromFields<{
                          current: FieldType<(...)>;
                          previous: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  rechargeable: true;
              };
          }, {
              component: false;
              flags: {
                  battery: false;
                  rechargeable: true;
              };
          }, {
              component: false;
              flags: {
                  battery: false;
                  replaceable: true;
              };
          }];
          features: {
              battery: BitFlag;
              rechargeable: BitFlag;
              replaceable: BitFlag;
              wired: BitFlag;
          };
          id: 47;
          name: "PowerSource";
          revision: 2;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            description: FixedAttribute<string, any>;
            endpointList: Attribute<EndpointNumber[], any>;
            order: Attribute<number, any>;
            status: Attribute<PowerSource.PowerSourceStatus, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any>;
                    wiredAssessedCurrent: OptionalAttribute<null | number, any>;
                    wiredAssessedInputFrequency: OptionalAttribute<null | number, any>;
                    wiredAssessedInputVoltage: OptionalAttribute<null | number, any>;
                    wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any>;
                    wiredMaximumCurrent: OptionalFixedAttribute<number, any>;
                    wiredNominalVoltage: OptionalFixedAttribute<number, any>;
                    wiredPresent: OptionalAttribute<boolean, any>;
                };
                events: {
                    wiredFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                wired: true;
            };
        }, {
            component: {
                attributes: {
                    activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any>;
                    batChargeLevel: Attribute<PowerSource.BatChargeLevel, any>;
                    batPercentRemaining: OptionalAttribute<null | number, any>;
                    batPresent: OptionalAttribute<boolean, any>;
                    batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any>;
                    batReplacementNeeded: Attribute<boolean, any>;
                    batTimeRemaining: OptionalAttribute<null | number, any>;
                    batVoltage: OptionalAttribute<null | number, any>;
                };
                events: {
                    batFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                battery: true;
            };
        }, {
            component: {
                attributes: {
                    batAnsiDesignation: OptionalFixedAttribute<string, any>;
                    batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any>;
                    batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any>;
                    batIecDesignation: OptionalFixedAttribute<string, any>;
                    batQuantity: FixedAttribute<number, any>;
                    batReplacementDescription: FixedAttribute<string, any>;
                };
            };
            flags: {
                replaceable: true;
            };
        }, {
            component: {
                attributes: {
                    batCapacity: OptionalFixedAttribute<number, any>;
                };
            };
            flags: {
                replaceable: true;
            };
        }, {
            component: {
                attributes: {
                    batCapacity: OptionalFixedAttribute<number, any>;
                };
            };
            flags: {
                rechargeable: true;
            };
        }, {
            component: {
                attributes: {
                    activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any>;
                    batChargeState: Attribute<PowerSource.BatChargeState, any>;
                    batChargingCurrent: OptionalAttribute<null | number, any>;
                    batFunctionalWhileCharging: Attribute<boolean, any>;
                    batTimeToFullCharge: OptionalAttribute<null | number, any>;
                };
                events: {
                    batChargeFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                rechargeable: true;
            };
        }, {
            component: false;
            flags: {
                battery: false;
                rechargeable: true;
            };
        }, {
            component: false;
            flags: {
                battery: false;
                replaceable: true;
            };
        }];
        features: {
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        };
        id: 47;
        name: "PowerSource";
        revision: 2;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            description: FixedAttribute<string, any>;
            endpointList: Attribute<EndpointNumber[], any>;
            order: Attribute<number, any>;
            status: Attribute<PowerSource.PowerSourceStatus, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any>;
                    wiredAssessedCurrent: OptionalAttribute<null | number, any>;
                    wiredAssessedInputFrequency: OptionalAttribute<null | number, any>;
                    wiredAssessedInputVoltage: OptionalAttribute<null | number, any>;
                    wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any>;
                    wiredMaximumCurrent: OptionalFixedAttribute<number, any>;
                    wiredNominalVoltage: OptionalFixedAttribute<number, any>;
                    wiredPresent: OptionalAttribute<boolean, any>;
                };
                events: {
                    wiredFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                wired: true;
            };
        }, {
            component: {
                attributes: {
                    activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any>;
                    batChargeLevel: Attribute<PowerSource.BatChargeLevel, any>;
                    batPercentRemaining: OptionalAttribute<null | number, any>;
                    batPresent: OptionalAttribute<boolean, any>;
                    batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any>;
                    batReplacementNeeded: Attribute<boolean, any>;
                    batTimeRemaining: OptionalAttribute<null | number, any>;
                    batVoltage: OptionalAttribute<null | number, any>;
                };
                events: {
                    batFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                battery: true;
            };
        }, {
            component: {
                attributes: {
                    batAnsiDesignation: OptionalFixedAttribute<string, any>;
                    batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any>;
                    batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any>;
                    batIecDesignation: OptionalFixedAttribute<string, any>;
                    batQuantity: FixedAttribute<number, any>;
                    batReplacementDescription: FixedAttribute<string, any>;
                };
            };
            flags: {
                replaceable: true;
            };
        }, {
            component: {
                attributes: {
                    batCapacity: OptionalFixedAttribute<number, any>;
                };
            };
            flags: {
                replaceable: true;
            };
        }, {
            component: {
                attributes: {
                    batCapacity: OptionalFixedAttribute<number, any>;
                };
            };
            flags: {
                rechargeable: true;
            };
        }, {
            component: {
                attributes: {
                    activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any>;
                    batChargeState: Attribute<PowerSource.BatChargeState, any>;
                    batChargingCurrent: OptionalAttribute<null | number, any>;
                    batFunctionalWhileCharging: Attribute<boolean, any>;
                    batTimeToFullCharge: OptionalAttribute<null | number, any>;
                };
                events: {
                    batChargeFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                rechargeable: true;
            };
        }, {
            component: false;
            flags: {
                battery: false;
                rechargeable: true;
            };
        }, {
            component: false;
            flags: {
                battery: false;
                replaceable: true;
            };
        }];
        features: {
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        };
        id: 47;
        name: "PowerSource";
        revision: 2;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              description: FixedAttribute<string, any>;
              endpointList: Attribute<EndpointNumber[], any>;
              order: Attribute<number, any>;
              status: Attribute<PowerSource.PowerSourceStatus, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any>;
                      wiredAssessedCurrent: OptionalAttribute<null | number, any>;
                      wiredAssessedInputFrequency: OptionalAttribute<null | number, any>;
                      wiredAssessedInputVoltage: OptionalAttribute<null | number, any>;
                      wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any>;
                      wiredMaximumCurrent: OptionalFixedAttribute<number, any>;
                      wiredNominalVoltage: OptionalFixedAttribute<number, any>;
                      wiredPresent: OptionalAttribute<boolean, any>;
                  };
                  events: {
                      wiredFaultChange: OptionalEvent<TypeFromFields<{
                          current: FieldType<(...)>;
                          previous: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  wired: true;
              };
          }, {
              component: {
                  attributes: {
                      activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any>;
                      batChargeLevel: Attribute<PowerSource.BatChargeLevel, any>;
                      batPercentRemaining: OptionalAttribute<null | number, any>;
                      batPresent: OptionalAttribute<boolean, any>;
                      batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any>;
                      batReplacementNeeded: Attribute<boolean, any>;
                      batTimeRemaining: OptionalAttribute<null | number, any>;
                      batVoltage: OptionalAttribute<null | number, any>;
                  };
                  events: {
                      batFaultChange: OptionalEvent<TypeFromFields<{
                          current: FieldType<(...)>;
                          previous: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  battery: true;
              };
          }, {
              component: {
                  attributes: {
                      batAnsiDesignation: OptionalFixedAttribute<string, any>;
                      batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any>;
                      batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any>;
                      batIecDesignation: OptionalFixedAttribute<string, any>;
                      batQuantity: FixedAttribute<number, any>;
                      batReplacementDescription: FixedAttribute<string, any>;
                  };
              };
              flags: {
                  replaceable: true;
              };
          }, {
              component: {
                  attributes: {
                      batCapacity: OptionalFixedAttribute<number, any>;
                  };
              };
              flags: {
                  replaceable: true;
              };
          }, {
              component: {
                  attributes: {
                      batCapacity: OptionalFixedAttribute<number, any>;
                  };
              };
              flags: {
                  rechargeable: true;
              };
          }, {
              component: {
                  attributes: {
                      activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any>;
                      batChargeState: Attribute<PowerSource.BatChargeState, any>;
                      batChargingCurrent: OptionalAttribute<null | number, any>;
                      batFunctionalWhileCharging: Attribute<boolean, any>;
                      batTimeToFullCharge: OptionalAttribute<null | number, any>;
                  };
                  events: {
                      batChargeFaultChange: OptionalEvent<TypeFromFields<{
                          current: FieldType<(...)>;
                          previous: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  rechargeable: true;
              };
          }, {
              component: false;
              flags: {
                  battery: false;
                  rechargeable: true;
              };
          }, {
              component: false;
              flags: {
                  battery: false;
                  replaceable: true;
              };
          }];
          features: {
              battery: BitFlag;
              rechargeable: BitFlag;
              replaceable: BitFlag;
              wired: BitFlag;
          };
          id: 47;
          name: "PowerSource";
          revision: 2;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            description: FixedAttribute<string, any>;
            endpointList: Attribute<EndpointNumber[], any>;
            order: Attribute<number, any>;
            status: Attribute<PowerSource.PowerSourceStatus, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any>;
                    wiredAssessedCurrent: OptionalAttribute<null | number, any>;
                    wiredAssessedInputFrequency: OptionalAttribute<null | number, any>;
                    wiredAssessedInputVoltage: OptionalAttribute<null | number, any>;
                    wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any>;
                    wiredMaximumCurrent: OptionalFixedAttribute<number, any>;
                    wiredNominalVoltage: OptionalFixedAttribute<number, any>;
                    wiredPresent: OptionalAttribute<boolean, any>;
                };
                events: {
                    wiredFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                wired: true;
            };
        }, {
            component: {
                attributes: {
                    activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any>;
                    batChargeLevel: Attribute<PowerSource.BatChargeLevel, any>;
                    batPercentRemaining: OptionalAttribute<null | number, any>;
                    batPresent: OptionalAttribute<boolean, any>;
                    batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any>;
                    batReplacementNeeded: Attribute<boolean, any>;
                    batTimeRemaining: OptionalAttribute<null | number, any>;
                    batVoltage: OptionalAttribute<null | number, any>;
                };
                events: {
                    batFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                battery: true;
            };
        }, {
            component: {
                attributes: {
                    batAnsiDesignation: OptionalFixedAttribute<string, any>;
                    batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any>;
                    batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any>;
                    batIecDesignation: OptionalFixedAttribute<string, any>;
                    batQuantity: FixedAttribute<number, any>;
                    batReplacementDescription: FixedAttribute<string, any>;
                };
            };
            flags: {
                replaceable: true;
            };
        }, {
            component: {
                attributes: {
                    batCapacity: OptionalFixedAttribute<number, any>;
                };
            };
            flags: {
                replaceable: true;
            };
        }, {
            component: {
                attributes: {
                    batCapacity: OptionalFixedAttribute<number, any>;
                };
            };
            flags: {
                rechargeable: true;
            };
        }, {
            component: {
                attributes: {
                    activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any>;
                    batChargeState: Attribute<PowerSource.BatChargeState, any>;
                    batChargingCurrent: OptionalAttribute<null | number, any>;
                    batFunctionalWhileCharging: Attribute<boolean, any>;
                    batTimeToFullCharge: OptionalAttribute<null | number, any>;
                };
                events: {
                    batChargeFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                rechargeable: true;
            };
        }, {
            component: false;
            flags: {
                battery: false;
                rechargeable: true;
            };
        }, {
            component: false;
            flags: {
                battery: false;
                replaceable: true;
            };
        }];
        features: {
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        };
        id: 47;
        name: "PowerSource";
        revision: 2;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            description: FixedAttribute<string, any>;
            endpointList: Attribute<EndpointNumber[], any>;
            order: Attribute<number, any>;
            status: Attribute<PowerSource.PowerSourceStatus, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any>;
                    wiredAssessedCurrent: OptionalAttribute<null | number, any>;
                    wiredAssessedInputFrequency: OptionalAttribute<null | number, any>;
                    wiredAssessedInputVoltage: OptionalAttribute<null | number, any>;
                    wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any>;
                    wiredMaximumCurrent: OptionalFixedAttribute<number, any>;
                    wiredNominalVoltage: OptionalFixedAttribute<number, any>;
                    wiredPresent: OptionalAttribute<boolean, any>;
                };
                events: {
                    wiredFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                wired: true;
            };
        }, {
            component: {
                attributes: {
                    activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any>;
                    batChargeLevel: Attribute<PowerSource.BatChargeLevel, any>;
                    batPercentRemaining: OptionalAttribute<null | number, any>;
                    batPresent: OptionalAttribute<boolean, any>;
                    batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any>;
                    batReplacementNeeded: Attribute<boolean, any>;
                    batTimeRemaining: OptionalAttribute<null | number, any>;
                    batVoltage: OptionalAttribute<null | number, any>;
                };
                events: {
                    batFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                battery: true;
            };
        }, {
            component: {
                attributes: {
                    batAnsiDesignation: OptionalFixedAttribute<string, any>;
                    batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any>;
                    batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any>;
                    batIecDesignation: OptionalFixedAttribute<string, any>;
                    batQuantity: FixedAttribute<number, any>;
                    batReplacementDescription: FixedAttribute<string, any>;
                };
            };
            flags: {
                replaceable: true;
            };
        }, {
            component: {
                attributes: {
                    batCapacity: OptionalFixedAttribute<number, any>;
                };
            };
            flags: {
                replaceable: true;
            };
        }, {
            component: {
                attributes: {
                    batCapacity: OptionalFixedAttribute<number, any>;
                };
            };
            flags: {
                rechargeable: true;
            };
        }, {
            component: {
                attributes: {
                    activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any>;
                    batChargeState: Attribute<PowerSource.BatChargeState, any>;
                    batChargingCurrent: OptionalAttribute<null | number, any>;
                    batFunctionalWhileCharging: Attribute<boolean, any>;
                    batTimeToFullCharge: OptionalAttribute<null | number, any>;
                };
                events: {
                    batChargeFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                rechargeable: true;
            };
        }, {
            component: false;
            flags: {
                battery: false;
                rechargeable: true;
            };
        }, {
            component: false;
            flags: {
                battery: false;
                replaceable: true;
            };
        }];
        features: {
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        };
        id: 47;
        name: "PowerSource";
        revision: 2;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          description: string;
          endpointList: number[];
          order: number;
          status: number;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            description: FixedAttribute<string, any>;
            endpointList: Attribute<EndpointNumber[], any>;
            order: Attribute<number, any>;
            status: Attribute<PowerSource.PowerSourceStatus, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any>;
                    wiredAssessedCurrent: OptionalAttribute<null | number, any>;
                    wiredAssessedInputFrequency: OptionalAttribute<null | number, any>;
                    wiredAssessedInputVoltage: OptionalAttribute<null | number, any>;
                    wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any>;
                    wiredMaximumCurrent: OptionalFixedAttribute<number, any>;
                    wiredNominalVoltage: OptionalFixedAttribute<number, any>;
                    wiredPresent: OptionalAttribute<boolean, any>;
                };
                events: {
                    wiredFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                wired: true;
            };
        }, {
            component: {
                attributes: {
                    activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any>;
                    batChargeLevel: Attribute<PowerSource.BatChargeLevel, any>;
                    batPercentRemaining: OptionalAttribute<null | number, any>;
                    batPresent: OptionalAttribute<boolean, any>;
                    batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any>;
                    batReplacementNeeded: Attribute<boolean, any>;
                    batTimeRemaining: OptionalAttribute<null | number, any>;
                    batVoltage: OptionalAttribute<null | number, any>;
                };
                events: {
                    batFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                battery: true;
            };
        }, {
            component: {
                attributes: {
                    batAnsiDesignation: OptionalFixedAttribute<string, any>;
                    batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any>;
                    batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any>;
                    batIecDesignation: OptionalFixedAttribute<string, any>;
                    batQuantity: FixedAttribute<number, any>;
                    batReplacementDescription: FixedAttribute<string, any>;
                };
            };
            flags: {
                replaceable: true;
            };
        }, {
            component: {
                attributes: {
                    batCapacity: OptionalFixedAttribute<number, any>;
                };
            };
            flags: {
                replaceable: true;
            };
        }, {
            component: {
                attributes: {
                    batCapacity: OptionalFixedAttribute<number, any>;
                };
            };
            flags: {
                rechargeable: true;
            };
        }, {
            component: {
                attributes: {
                    activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any>;
                    batChargeState: Attribute<PowerSource.BatChargeState, any>;
                    batChargingCurrent: OptionalAttribute<null | number, any>;
                    batFunctionalWhileCharging: Attribute<boolean, any>;
                    batTimeToFullCharge: OptionalAttribute<null | number, any>;
                };
                events: {
                    batChargeFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                rechargeable: true;
            };
        }, {
            component: false;
            flags: {
                battery: false;
                rechargeable: true;
            };
        }, {
            component: false;
            flags: {
                battery: false;
                replaceable: true;
            };
        }];
        features: {
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        };
        id: 47;
        name: "PowerSource";
        revision: 2;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            description: FixedAttribute<string, any>;
            endpointList: Attribute<EndpointNumber[], any>;
            order: Attribute<number, any>;
            status: Attribute<PowerSource.PowerSourceStatus, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any>;
                    wiredAssessedCurrent: OptionalAttribute<null | number, any>;
                    wiredAssessedInputFrequency: OptionalAttribute<null | number, any>;
                    wiredAssessedInputVoltage: OptionalAttribute<null | number, any>;
                    wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any>;
                    wiredMaximumCurrent: OptionalFixedAttribute<number, any>;
                    wiredNominalVoltage: OptionalFixedAttribute<number, any>;
                    wiredPresent: OptionalAttribute<boolean, any>;
                };
                events: {
                    wiredFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                wired: true;
            };
        }, {
            component: {
                attributes: {
                    activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any>;
                    batChargeLevel: Attribute<PowerSource.BatChargeLevel, any>;
                    batPercentRemaining: OptionalAttribute<null | number, any>;
                    batPresent: OptionalAttribute<boolean, any>;
                    batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any>;
                    batReplacementNeeded: Attribute<boolean, any>;
                    batTimeRemaining: OptionalAttribute<null | number, any>;
                    batVoltage: OptionalAttribute<null | number, any>;
                };
                events: {
                    batFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                battery: true;
            };
        }, {
            component: {
                attributes: {
                    batAnsiDesignation: OptionalFixedAttribute<string, any>;
                    batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any>;
                    batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any>;
                    batIecDesignation: OptionalFixedAttribute<string, any>;
                    batQuantity: FixedAttribute<number, any>;
                    batReplacementDescription: FixedAttribute<string, any>;
                };
            };
            flags: {
                replaceable: true;
            };
        }, {
            component: {
                attributes: {
                    batCapacity: OptionalFixedAttribute<number, any>;
                };
            };
            flags: {
                replaceable: true;
            };
        }, {
            component: {
                attributes: {
                    batCapacity: OptionalFixedAttribute<number, any>;
                };
            };
            flags: {
                rechargeable: true;
            };
        }, {
            component: {
                attributes: {
                    activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any>;
                    batChargeState: Attribute<PowerSource.BatChargeState, any>;
                    batChargingCurrent: OptionalAttribute<null | number, any>;
                    batFunctionalWhileCharging: Attribute<boolean, any>;
                    batTimeToFullCharge: OptionalAttribute<null | number, any>;
                };
                events: {
                    batChargeFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                rechargeable: true;
            };
        }, {
            component: false;
            flags: {
                battery: false;
                rechargeable: true;
            };
        }, {
            component: false;
            flags: {
                battery: false;
                replaceable: true;
            };
        }];
        features: {
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        };
        id: 47;
        name: "PowerSource";
        revision: 2;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              description: FixedAttribute<string, any>;
              endpointList: Attribute<EndpointNumber[], any>;
              order: Attribute<number, any>;
              status: Attribute<PowerSource.PowerSourceStatus, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any>;
                      wiredAssessedCurrent: OptionalAttribute<null | number, any>;
                      wiredAssessedInputFrequency: OptionalAttribute<null | number, any>;
                      wiredAssessedInputVoltage: OptionalAttribute<null | number, any>;
                      wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any>;
                      wiredMaximumCurrent: OptionalFixedAttribute<number, any>;
                      wiredNominalVoltage: OptionalFixedAttribute<number, any>;
                      wiredPresent: OptionalAttribute<boolean, any>;
                  };
                  events: {
                      wiredFaultChange: OptionalEvent<TypeFromFields<{
                          current: FieldType<(...)>;
                          previous: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  wired: true;
              };
          }, {
              component: {
                  attributes: {
                      activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any>;
                      batChargeLevel: Attribute<PowerSource.BatChargeLevel, any>;
                      batPercentRemaining: OptionalAttribute<null | number, any>;
                      batPresent: OptionalAttribute<boolean, any>;
                      batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any>;
                      batReplacementNeeded: Attribute<boolean, any>;
                      batTimeRemaining: OptionalAttribute<null | number, any>;
                      batVoltage: OptionalAttribute<null | number, any>;
                  };
                  events: {
                      batFaultChange: OptionalEvent<TypeFromFields<{
                          current: FieldType<(...)>;
                          previous: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  battery: true;
              };
          }, {
              component: {
                  attributes: {
                      batAnsiDesignation: OptionalFixedAttribute<string, any>;
                      batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any>;
                      batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any>;
                      batIecDesignation: OptionalFixedAttribute<string, any>;
                      batQuantity: FixedAttribute<number, any>;
                      batReplacementDescription: FixedAttribute<string, any>;
                  };
              };
              flags: {
                  replaceable: true;
              };
          }, {
              component: {
                  attributes: {
                      batCapacity: OptionalFixedAttribute<number, any>;
                  };
              };
              flags: {
                  replaceable: true;
              };
          }, {
              component: {
                  attributes: {
                      batCapacity: OptionalFixedAttribute<number, any>;
                  };
              };
              flags: {
                  rechargeable: true;
              };
          }, {
              component: {
                  attributes: {
                      activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any>;
                      batChargeState: Attribute<PowerSource.BatChargeState, any>;
                      batChargingCurrent: OptionalAttribute<null | number, any>;
                      batFunctionalWhileCharging: Attribute<boolean, any>;
                      batTimeToFullCharge: OptionalAttribute<null | number, any>;
                  };
                  events: {
                      batChargeFaultChange: OptionalEvent<TypeFromFields<{
                          current: FieldType<(...)>;
                          previous: FieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  rechargeable: true;
              };
          }, {
              component: false;
              flags: {
                  battery: false;
                  rechargeable: true;
              };
          }, {
              component: false;
              flags: {
                  battery: false;
                  replaceable: true;
              };
          }];
          features: {
              battery: BitFlag;
              rechargeable: BitFlag;
              replaceable: BitFlag;
              wired: BitFlag;
          };
          id: 47;
          name: "PowerSource";
          revision: 2;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            description: FixedAttribute<string, any>;
            endpointList: Attribute<EndpointNumber[], any>;
            order: Attribute<number, any>;
            status: Attribute<PowerSource.PowerSourceStatus, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    activeWiredFaults: OptionalAttribute<PowerSource.WiredFault[], any>;
                    wiredAssessedCurrent: OptionalAttribute<null | number, any>;
                    wiredAssessedInputFrequency: OptionalAttribute<null | number, any>;
                    wiredAssessedInputVoltage: OptionalAttribute<null | number, any>;
                    wiredCurrentType: FixedAttribute<PowerSource.WiredCurrentType, any>;
                    wiredMaximumCurrent: OptionalFixedAttribute<number, any>;
                    wiredNominalVoltage: OptionalFixedAttribute<number, any>;
                    wiredPresent: OptionalAttribute<boolean, any>;
                };
                events: {
                    wiredFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                wired: true;
            };
        }, {
            component: {
                attributes: {
                    activeBatFaults: OptionalAttribute<PowerSource.BatFault[], any>;
                    batChargeLevel: Attribute<PowerSource.BatChargeLevel, any>;
                    batPercentRemaining: OptionalAttribute<null | number, any>;
                    batPresent: OptionalAttribute<boolean, any>;
                    batReplaceability: FixedAttribute<PowerSource.BatReplaceability, any>;
                    batReplacementNeeded: Attribute<boolean, any>;
                    batTimeRemaining: OptionalAttribute<null | number, any>;
                    batVoltage: OptionalAttribute<null | number, any>;
                };
                events: {
                    batFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                battery: true;
            };
        }, {
            component: {
                attributes: {
                    batAnsiDesignation: OptionalFixedAttribute<string, any>;
                    batApprovedChemistry: OptionalFixedAttribute<PowerSource.BatApprovedChemistry, any>;
                    batCommonDesignation: OptionalFixedAttribute<PowerSource.BatCommonDesignation, any>;
                    batIecDesignation: OptionalFixedAttribute<string, any>;
                    batQuantity: FixedAttribute<number, any>;
                    batReplacementDescription: FixedAttribute<string, any>;
                };
            };
            flags: {
                replaceable: true;
            };
        }, {
            component: {
                attributes: {
                    batCapacity: OptionalFixedAttribute<number, any>;
                };
            };
            flags: {
                replaceable: true;
            };
        }, {
            component: {
                attributes: {
                    batCapacity: OptionalFixedAttribute<number, any>;
                };
            };
            flags: {
                rechargeable: true;
            };
        }, {
            component: {
                attributes: {
                    activeBatChargeFaults: OptionalAttribute<PowerSource.BatChargeFault[], any>;
                    batChargeState: Attribute<PowerSource.BatChargeState, any>;
                    batChargingCurrent: OptionalAttribute<null | number, any>;
                    batFunctionalWhileCharging: Attribute<boolean, any>;
                    batTimeToFullCharge: OptionalAttribute<null | number, any>;
                };
                events: {
                    batChargeFaultChange: OptionalEvent<TypeFromFields<{
                        current: FieldType<(...)>;
                        previous: FieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                rechargeable: true;
            };
        }, {
            component: false;
            flags: {
                battery: false;
                rechargeable: true;
            };
        }, {
            component: false;
            flags: {
                battery: false;
                replaceable: true;
            };
        }];
        features: {
            battery: BitFlag;
            rechargeable: BitFlag;
            replaceable: BitFlag;
            wired: BitFlag;
        };
        id: 47;
        name: "PowerSource";
        revision: 2;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods