Interface Complete

This cluster supports all BooleanStateConfiguration 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>;
        alarmsActive: Attribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
        };
        alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                alarmSuppress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        attributeList: Attribute<AttributeId[], never>;
        clusterRevision: Attribute<number, never>;
        currentSensitivityLevel: WritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                sensitivityLevel: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        defaultSensitivityLevel: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                sensitivityLevel: boolean;
            }];
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
            generalFault: BitFlag;
        }>, any>;
        supportedSensitivityLevels: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                sensitivityLevel: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    }, GlobalAttributes<{
        alarmSuppress: BitFlag;
        audible: BitFlag;
        sensitivityLevel: BitFlag;
        visual: BitFlag;
    }>>;
    base: undefined;
    commands: {
        enableDisableAlarm: Command<TypeFromFields<{
            alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        suppressAlarm: Command<TypeFromFields<{
            alarmsToSuppress: FieldType<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                alarmSuppress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        alarmsStateChanged: Event<TypeFromFields<{
            alarmsActive: FieldType<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>>;
            alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        sensorFault: OptionalEvent<TypeFromFields<{
            sensorFault: FieldType<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>>;
        }>, any>;
    };
    extensions: undefined;
    features: {
        alarmSuppress: BitFlag;
        audible: BitFlag;
        sensitivityLevel: BitFlag;
        visual: BitFlag;
    };
    id: Branded<Branded<128, "ClusterId">, "ClusterId">;
    name: "BooleanStateConfiguration";
    revision: 1;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            alarmsActive: Attribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    visual: boolean;
                }, {
                    audible: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    visual: boolean;
                }, {
                    audible: boolean;
                }];
            };
            alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    visual: boolean;
                }, {
                    audible: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    alarmSuppress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            currentSensitivityLevel: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    sensitivityLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            defaultSensitivityLevel: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    sensitivityLevel: boolean;
                }];
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                alarmSuppress: BitFlag;
                audible: BitFlag;
                sensitivityLevel: BitFlag;
                visual: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>, any>;
            supportedSensitivityLevels: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    sensitivityLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            enableDisableAlarm: Command<TypeFromFields<{
                alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
                    audible: ...;
                    visual: ...;
                }>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    visual: boolean;
                }, {
                    audible: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            suppressAlarm: Command<TypeFromFields<{
                alarmsToSuppress: FieldType<TypeFromPartialBitSchema<{
                    audible: ...;
                    visual: ...;
                }>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    alarmSuppress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            alarmsStateChanged: Event<TypeFromFields<{
                alarmsActive: FieldType<TypeFromPartialBitSchema<{
                    audible: ...;
                    visual: ...;
                }>>;
                alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
                    audible: ...;
                    visual: ...;
                }>>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    visual: boolean;
                }, {
                    audible: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            sensorFault: OptionalEvent<TypeFromFields<{
                sensorFault: FieldType<TypeFromPartialBitSchema<{
                    generalFault: BitFlag;
                }>>;
            }>, any>;
        };
        features: {
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        };
        id: Branded<128, "ClusterId">;
        name: "BooleanStateConfiguration";
        revision: 1;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            alarmsActive: Attribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    visual: boolean;
                }, {
                    audible: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    visual: boolean;
                }, {
                    audible: boolean;
                }];
            };
            alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    visual: boolean;
                }, {
                    audible: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    alarmSuppress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            currentSensitivityLevel: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    sensitivityLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            defaultSensitivityLevel: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    sensitivityLevel: boolean;
                }];
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                alarmSuppress: BitFlag;
                audible: BitFlag;
                sensitivityLevel: BitFlag;
                visual: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>, any>;
            supportedSensitivityLevels: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    sensitivityLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            enableDisableAlarm: Command<TypeFromFields<{
                alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
                    audible: ...;
                    visual: ...;
                }>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    visual: boolean;
                }, {
                    audible: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            suppressAlarm: Command<TypeFromFields<{
                alarmsToSuppress: FieldType<TypeFromPartialBitSchema<{
                    audible: ...;
                    visual: ...;
                }>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    alarmSuppress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            alarmsStateChanged: Event<TypeFromFields<{
                alarmsActive: FieldType<TypeFromPartialBitSchema<{
                    audible: ...;
                    visual: ...;
                }>>;
                alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
                    audible: ...;
                    visual: ...;
                }>>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    visual: boolean;
                }, {
                    audible: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            sensorFault: OptionalEvent<TypeFromFields<{
                sensorFault: FieldType<TypeFromPartialBitSchema<{
                    generalFault: BitFlag;
                }>>;
            }>, any>;
        };
        features: {
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        };
        id: Branded<128, "ClusterId">;
        name: "BooleanStateConfiguration";
        revision: 1;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            alarmsActive: Attribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    visual: boolean;
                }, {
                    audible: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    visual: boolean;
                }, {
                    audible: boolean;
                }];
            };
            alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    visual: boolean;
                }, {
                    audible: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    alarmSuppress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            currentSensitivityLevel: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    sensitivityLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            defaultSensitivityLevel: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    sensitivityLevel: boolean;
                }];
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                alarmSuppress: BitFlag;
                audible: BitFlag;
                sensitivityLevel: BitFlag;
                visual: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>, any>;
            supportedSensitivityLevels: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    sensitivityLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            enableDisableAlarm: Command<TypeFromFields<{
                alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
                    audible: ...;
                    visual: ...;
                }>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    visual: boolean;
                }, {
                    audible: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            suppressAlarm: Command<TypeFromFields<{
                alarmsToSuppress: FieldType<TypeFromPartialBitSchema<{
                    audible: ...;
                    visual: ...;
                }>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    alarmSuppress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            alarmsStateChanged: Event<TypeFromFields<{
                alarmsActive: FieldType<TypeFromPartialBitSchema<{
                    audible: ...;
                    visual: ...;
                }>>;
                alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
                    audible: ...;
                    visual: ...;
                }>>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    visual: boolean;
                }, {
                    audible: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            sensorFault: OptionalEvent<TypeFromFields<{
                sensorFault: FieldType<TypeFromPartialBitSchema<{
                    generalFault: BitFlag;
                }>>;
            }>, any>;
        };
        features: {
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        };
        id: Branded<128, "ClusterId">;
        name: "BooleanStateConfiguration";
        revision: 1;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            alarmsActive: Attribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    visual: boolean;
                }, {
                    audible: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    visual: boolean;
                }, {
                    audible: boolean;
                }];
            };
            alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    visual: boolean;
                }, {
                    audible: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    alarmSuppress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            currentSensitivityLevel: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    sensitivityLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            defaultSensitivityLevel: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    sensitivityLevel: boolean;
                }];
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                alarmSuppress: BitFlag;
                audible: BitFlag;
                sensitivityLevel: BitFlag;
                visual: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>, any>;
            supportedSensitivityLevels: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    sensitivityLevel: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            enableDisableAlarm: Command<TypeFromFields<{
                alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
                    audible: ...;
                    visual: ...;
                }>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    visual: boolean;
                }, {
                    audible: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            suppressAlarm: Command<TypeFromFields<{
                alarmsToSuppress: FieldType<TypeFromPartialBitSchema<{
                    audible: ...;
                    visual: ...;
                }>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    alarmSuppress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        events: {
            alarmsStateChanged: Event<TypeFromFields<{
                alarmsActive: FieldType<TypeFromPartialBitSchema<{
                    audible: ...;
                    visual: ...;
                }>>;
                alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
                    audible: ...;
                    visual: ...;
                }>>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    visual: boolean;
                }, {
                    audible: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            sensorFault: OptionalEvent<TypeFromFields<{
                sensorFault: FieldType<TypeFromPartialBitSchema<{
                    generalFault: BitFlag;
                }>>;
            }>, any>;
        };
        features: {
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        };
        id: Branded<128, "ClusterId">;
        name: "BooleanStateConfiguration";
        revision: 1;
    }>, SelectionT>;
}

Hierarchy (view full)

Identity<typeof BooleanStateConfiguration.CompleteInstance>
- Complete

Index

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    acceptedCommandList: Attribute<CommandId[], never>;
    alarmsActive: Attribute<TypeFromPartialBitSchema<{
        audible: BitFlag;
        visual: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            visual: boolean;
        }, {
            audible: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
        audible: BitFlag;
        visual: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            visual: boolean;
        }, {
            audible: boolean;
        }];
    };
    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
        audible: BitFlag;
        visual: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            visual: boolean;
        }, {
            audible: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
        audible: BitFlag;
        visual: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            alarmSuppress: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    attributeList: Attribute<AttributeId[], never>;
    clusterRevision: Attribute<number, never>;
    currentSensitivityLevel: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            sensitivityLevel: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    defaultSensitivityLevel: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            sensitivityLevel: boolean;
        }];
    };
    featureMap: Attribute<TypeFromPartialBitSchema<{
        alarmSuppress: BitFlag;
        audible: BitFlag;
        sensitivityLevel: BitFlag;
        visual: BitFlag;
    }>, never>;
    generatedCommandList: Attribute<CommandId[], never>;
    sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
        generalFault: BitFlag;
    }>, any>;
    supportedSensitivityLevels: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            sensitivityLevel: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}, GlobalAttributes<{
    alarmSuppress: BitFlag;
    audible: BitFlag;
    sensitivityLevel: BitFlag;
    visual: BitFlag;
}>>

Type declaration

ReadonlyacceptedCommandList: Attribute<CommandId[], never>
List of client generated commands which are supported by this cluster server instance.
ReadonlyalarmsActive: Attribute<TypeFromPartialBitSchema<{
    audible: BitFlag;
    visual: BitFlag;
}>, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        visual: boolean;
    }, {
        audible: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyalarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
    audible: BitFlag;
    visual: BitFlag;
}>, any> & {
    isConditional: true;
    mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
    optional: true;
    optionalIf: [] | [{
        visual: boolean;
    }, {
        audible: boolean;
    }];
}
ReadonlyalarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
    audible: BitFlag;
    visual: BitFlag;
}>, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        visual: boolean;
    }, {
        audible: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyalarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
    audible: BitFlag;
    visual: BitFlag;
}>, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        alarmSuppress: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlyattributeList: Attribute<AttributeId[], never>
List of the attribute IDs of the attributes supported by the cluster instance.
ReadonlyclusterRevision: Attribute<number, never>
Indicates the revision of the server cluster specification supported by the cluster instance.
ReadonlycurrentSensitivityLevel: WritableAttribute<number, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        sensitivityLevel: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlydefaultSensitivityLevel: OptionalFixedAttribute<number, any> & {
    isConditional: true;
    mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
    optional: true;
    optionalIf: [] | [{
        sensitivityLevel: boolean;
    }];
}
ReadonlyfeatureMap: Attribute<TypeFromPartialBitSchema<{
    alarmSuppress: BitFlag;
    audible: BitFlag;
    sensitivityLevel: BitFlag;
    visual: 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).
ReadonlysensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
generalFault: BitFlag;
}>, any>
Indicates any faults registered by the device.

See
MatterSpecification.v13.Cluster § 1.8.6.8
ReadonlysupportedSensitivityLevels: FixedAttribute<number, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        sensitivityLevel: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

base

base: undefined

commands

commands: {
    enableDisableAlarm: Command<TypeFromFields<{
        alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            visual: boolean;
        }, {
            audible: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    suppressAlarm: Command<TypeFromFields<{
        alarmsToSuppress: FieldType<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            alarmSuppress: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}

events

events: {
    alarmsStateChanged: Event<TypeFromFields<{
        alarmsActive: FieldType<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>>;
        alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            visual: boolean;
        }, {
            audible: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    sensorFault: OptionalEvent<TypeFromFields<{
        sensorFault: FieldType<TypeFromPartialBitSchema<{
            generalFault: BitFlag;
        }>>;
    }>, any>;
}

Type declaration

ReadonlyalarmsStateChanged: Event<TypeFromFields<{
    alarmsActive: FieldType<TypeFromPartialBitSchema<{
        audible: BitFlag;
        visual: BitFlag;
    }>>;
    alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
        audible: BitFlag;
        visual: BitFlag;
    }>>;
}>, any> & {
    isConditional: true;
    mandatoryIf: [] | [{
        visual: boolean;
    }, {
        audible: boolean;
    }];
    optional: true;
    optionalIf: [] | ConditionalFeatureList<BitSchema>;
}
ReadonlysensorFault: OptionalEvent<TypeFromFields<{
    sensorFault: FieldType<TypeFromPartialBitSchema<{
        generalFault: BitFlag;
    }>>;
}>, any>
This event shall be generated when the device registers or clears a fault.

See
MatterSpecification.v13.Cluster § 1.8.8.2

extensions

extensions: undefined

features

features: {
    alarmSuppress: BitFlag;
    audible: BitFlag;
    sensitivityLevel: BitFlag;
    visual: BitFlag;
}

Type declaration

ReadonlyalarmSuppress: BitFlag
AlarmSuppress

This feature shall indicate that the device is able to suppress the supported alarm modes, when the user acknowledges the alarm. This is intended to stop visual and/or audible alarms, when the user has become aware that the sensor is triggered, but it is no longer desired to have the alarm modes active on the device, e.g.:

• The triggering cause have been resolved by the user, but the sensor has not yet stopped detecting the triggering cause.

• The user is not able to address the triggering cause, but is aware of the alarm and suppress/acknowledge it be addressed at a later point.

Acknowledge of alarms will for the remainder of this cluster be referred to as suppress.

A suppressed alarm is still considered active and will remain so unless it is actively disabled or the triggering condition is not longer present. The action of suppressing an alarm mode is only applicable to and is intended to stop the physical alarming, e.g. emitting a sound or blinking a light; it does not impact alarm reporting in AlarmsActive.

See
MatterSpecification.v13.Cluster § 1.8.4.1
Readonlyaudible: BitFlag
Audible

Supports audible alarms
ReadonlysensitivityLevel: BitFlag
SensitivityLevel

Supports ability to set sensor sensitivity
Readonlyvisual: BitFlag
Visual

Supports visual alarms

id

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

name

revision

supportedFeatures

supportedFeatures: {}

unknown

Methods

alter

alter<const AlterationsT>(alterations): WithAlterations<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        alarmsActive: Attribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
        };
        alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                alarmSuppress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        attributeList: Attribute<AttributeId[], never>;
        clusterRevision: Attribute<number, never>;
        currentSensitivityLevel: WritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                sensitivityLevel: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        defaultSensitivityLevel: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                sensitivityLevel: boolean;
            }];
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
            generalFault: BitFlag;
        }>, any>;
        supportedSensitivityLevels: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                sensitivityLevel: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        enableDisableAlarm: Command<TypeFromFields<{
            alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        suppressAlarm: Command<TypeFromFields<{
            alarmsToSuppress: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                alarmSuppress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        alarmsStateChanged: Event<TypeFromFields<{
            alarmsActive: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
            alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        sensorFault: OptionalEvent<TypeFromFields<{
            sensorFault: FieldType<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>>;
        }>, any>;
    };
    features: {
        alarmSuppress: BitFlag;
        audible: BitFlag;
        sensitivityLevel: BitFlag;
        visual: BitFlag;
    };
    id: Branded<128, "ClusterId">;
    name: "BooleanStateConfiguration";
    revision: 1;
}>, AlterationsT>
Modify elements using ElementModifier.alter.
Type Parameters
- const AlterationsT extends Alterations<Of<{
      attributes: {
          acceptedCommandList: Attribute<CommandId[], never>;
          alarmsActive: Attribute<TypeFromPartialBitSchema<{
              audible: BitFlag;
              visual: BitFlag;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  visual: boolean;
              }, {
                  audible: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
              audible: BitFlag;
              visual: BitFlag;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  visual: boolean;
              }, {
                  audible: boolean;
              }];
          };
          alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
              audible: BitFlag;
              visual: BitFlag;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  visual: boolean;
              }, {
                  audible: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
              audible: BitFlag;
              visual: BitFlag;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  alarmSuppress: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          attributeList: Attribute<AttributeId[], never>;
          clusterRevision: Attribute<number, never>;
          currentSensitivityLevel: WritableAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  sensitivityLevel: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          defaultSensitivityLevel: OptionalFixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  sensitivityLevel: boolean;
              }];
          };
          featureMap: Attribute<TypeFromPartialBitSchema<{
              alarmSuppress: BitFlag;
              audible: BitFlag;
              sensitivityLevel: BitFlag;
              visual: BitFlag;
          }>, never>;
          generatedCommandList: Attribute<CommandId[], never>;
          sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
              generalFault: BitFlag;
          }>, any>;
          supportedSensitivityLevels: FixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  sensitivityLevel: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      commands: {
          enableDisableAlarm: Command<TypeFromFields<{
              alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
                  audible: ...;
                  visual: ...;
              }>>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  visual: boolean;
              }, {
                  audible: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          suppressAlarm: Command<TypeFromFields<{
              alarmsToSuppress: FieldType<TypeFromPartialBitSchema<{
                  audible: ...;
                  visual: ...;
              }>>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  alarmSuppress: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      events: {
          alarmsStateChanged: Event<TypeFromFields<{
              alarmsActive: FieldType<TypeFromPartialBitSchema<{
                  audible: ...;
                  visual: ...;
              }>>;
              alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
                  audible: ...;
                  visual: ...;
              }>>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  visual: boolean;
              }, {
                  audible: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          sensorFault: OptionalEvent<TypeFromFields<{
              sensorFault: FieldType<TypeFromPartialBitSchema<{
                  generalFault: BitFlag;
              }>>;
          }>, any>;
      };
      features: {
          alarmSuppress: BitFlag;
          audible: BitFlag;
          sensitivityLevel: BitFlag;
          visual: BitFlag;
      };
      id: Branded<128, "ClusterId">;
      name: "BooleanStateConfiguration";
      revision: 1;
  }>>
Parameters
- alterations: AlterationsT
Returns WithAlterations<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        alarmsActive: Attribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
        };
        alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                alarmSuppress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        attributeList: Attribute<AttributeId[], never>;
        clusterRevision: Attribute<number, never>;
        currentSensitivityLevel: WritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                sensitivityLevel: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        defaultSensitivityLevel: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                sensitivityLevel: boolean;
            }];
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
            generalFault: BitFlag;
        }>, any>;
        supportedSensitivityLevels: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                sensitivityLevel: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        enableDisableAlarm: Command<TypeFromFields<{
            alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        suppressAlarm: Command<TypeFromFields<{
            alarmsToSuppress: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                alarmSuppress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        alarmsStateChanged: Event<TypeFromFields<{
            alarmsActive: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
            alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        sensorFault: OptionalEvent<TypeFromFields<{
            sensorFault: FieldType<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>>;
        }>, any>;
    };
    features: {
        alarmSuppress: BitFlag;
        audible: BitFlag;
        sensitivityLevel: BitFlag;
        visual: BitFlag;
    };
    id: Branded<128, "ClusterId">;
    name: "BooleanStateConfiguration";
    revision: 1;
}>, AlterationsT>
Inherited from Identity.alter
- Defined in packages/types/src/cluster/mutation/MutableCluster.ts:82

enable

enable<const FlagsT>(flags): WithFlags<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        alarmsActive: Attribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
        };
        alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                alarmSuppress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        attributeList: Attribute<AttributeId[], never>;
        clusterRevision: Attribute<number, never>;
        currentSensitivityLevel: WritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                sensitivityLevel: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        defaultSensitivityLevel: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                sensitivityLevel: boolean;
            }];
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
            generalFault: BitFlag;
        }>, any>;
        supportedSensitivityLevels: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                sensitivityLevel: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        enableDisableAlarm: Command<TypeFromFields<{
            alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        suppressAlarm: Command<TypeFromFields<{
            alarmsToSuppress: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                alarmSuppress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        alarmsStateChanged: Event<TypeFromFields<{
            alarmsActive: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
            alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        sensorFault: OptionalEvent<TypeFromFields<{
            sensorFault: FieldType<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>>;
        }>, any>;
    };
    features: {
        alarmSuppress: BitFlag;
        audible: BitFlag;
        sensitivityLevel: BitFlag;
        visual: BitFlag;
    };
    id: Branded<128, "ClusterId">;
    name: "BooleanStateConfiguration";
    revision: 1;
}>, FlagsT>
Modify elements using ElementModifier.enable.
Type Parameters
- const FlagsT extends ElementFlags<Of<{
      attributes: {
          acceptedCommandList: Attribute<CommandId[], never>;
          alarmsActive: Attribute<TypeFromPartialBitSchema<{
              audible: BitFlag;
              visual: BitFlag;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  visual: boolean;
              }, {
                  audible: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
              audible: BitFlag;
              visual: BitFlag;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  visual: boolean;
              }, {
                  audible: boolean;
              }];
          };
          alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
              audible: BitFlag;
              visual: BitFlag;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  visual: boolean;
              }, {
                  audible: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
              audible: BitFlag;
              visual: BitFlag;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  alarmSuppress: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          attributeList: Attribute<AttributeId[], never>;
          clusterRevision: Attribute<number, never>;
          currentSensitivityLevel: WritableAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  sensitivityLevel: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          defaultSensitivityLevel: OptionalFixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  sensitivityLevel: boolean;
              }];
          };
          featureMap: Attribute<TypeFromPartialBitSchema<{
              alarmSuppress: BitFlag;
              audible: BitFlag;
              sensitivityLevel: BitFlag;
              visual: BitFlag;
          }>, never>;
          generatedCommandList: Attribute<CommandId[], never>;
          sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
              generalFault: BitFlag;
          }>, any>;
          supportedSensitivityLevels: FixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  sensitivityLevel: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      commands: {
          enableDisableAlarm: Command<TypeFromFields<{
              alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
                  audible: ...;
                  visual: ...;
              }>>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  visual: boolean;
              }, {
                  audible: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          suppressAlarm: Command<TypeFromFields<{
              alarmsToSuppress: FieldType<TypeFromPartialBitSchema<{
                  audible: ...;
                  visual: ...;
              }>>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  alarmSuppress: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      events: {
          alarmsStateChanged: Event<TypeFromFields<{
              alarmsActive: FieldType<TypeFromPartialBitSchema<{
                  audible: ...;
                  visual: ...;
              }>>;
              alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
                  audible: ...;
                  visual: ...;
              }>>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  visual: boolean;
              }, {
                  audible: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          sensorFault: OptionalEvent<TypeFromFields<{
              sensorFault: FieldType<TypeFromPartialBitSchema<{
                  generalFault: BitFlag;
              }>>;
          }>, any>;
      };
      features: {
          alarmSuppress: BitFlag;
          audible: BitFlag;
          sensitivityLevel: BitFlag;
          visual: BitFlag;
      };
      id: Branded<128, "ClusterId">;
      name: "BooleanStateConfiguration";
      revision: 1;
  }>>
Parameters
- flags: FlagsT
Returns WithFlags<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        alarmsActive: Attribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
        };
        alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                alarmSuppress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        attributeList: Attribute<AttributeId[], never>;
        clusterRevision: Attribute<number, never>;
        currentSensitivityLevel: WritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                sensitivityLevel: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        defaultSensitivityLevel: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                sensitivityLevel: boolean;
            }];
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
            generalFault: BitFlag;
        }>, any>;
        supportedSensitivityLevels: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                sensitivityLevel: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        enableDisableAlarm: Command<TypeFromFields<{
            alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        suppressAlarm: Command<TypeFromFields<{
            alarmsToSuppress: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                alarmSuppress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        alarmsStateChanged: Event<TypeFromFields<{
            alarmsActive: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
            alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        sensorFault: OptionalEvent<TypeFromFields<{
            sensorFault: FieldType<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>>;
        }>, any>;
    };
    features: {
        alarmSuppress: BitFlag;
        audible: BitFlag;
        sensitivityLevel: BitFlag;
        visual: BitFlag;
    };
    id: Branded<128, "ClusterId">;
    name: "BooleanStateConfiguration";
    revision: 1;
}>, FlagsT>
Inherited from Identity.enable
- Defined in packages/types/src/cluster/mutation/MutableCluster.ts:96

set

set<const ValuesT>(values): WithValues<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        alarmsActive: Attribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
        };
        alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                alarmSuppress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        attributeList: Attribute<AttributeId[], never>;
        clusterRevision: Attribute<number, never>;
        currentSensitivityLevel: WritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                sensitivityLevel: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        defaultSensitivityLevel: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                sensitivityLevel: boolean;
            }];
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
            generalFault: BitFlag;
        }>, any>;
        supportedSensitivityLevels: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                sensitivityLevel: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        enableDisableAlarm: Command<TypeFromFields<{
            alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        suppressAlarm: Command<TypeFromFields<{
            alarmsToSuppress: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                alarmSuppress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        alarmsStateChanged: Event<TypeFromFields<{
            alarmsActive: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
            alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        sensorFault: OptionalEvent<TypeFromFields<{
            sensorFault: FieldType<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>>;
        }>, any>;
    };
    features: {
        alarmSuppress: BitFlag;
        audible: BitFlag;
        sensitivityLevel: BitFlag;
        visual: BitFlag;
    };
    id: Branded<128, "ClusterId">;
    name: "BooleanStateConfiguration";
    revision: 1;
}>, ValuesT>
Modify elements using ElementModifier.set.
Type Parameters
- const ValuesT extends {
      alarmsActive?: {
          audible?: boolean;
          visual?: boolean;
      };
      alarmsEnabled?: {
          audible?: boolean;
          visual?: boolean;
      };
      alarmsSupported?: {
          audible?: boolean;
          visual?: boolean;
      };
      alarmsSuppressed?: {
          audible?: boolean;
          visual?: boolean;
      };
      currentSensitivityLevel?: number;
      defaultSensitivityLevel?: number;
      sensorFault?: {
          generalFault?: boolean;
      };
      supportedSensitivityLevels?: number;
  }
Parameters
- values: ValuesT
Returns WithValues<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        alarmsActive: Attribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
        };
        alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                alarmSuppress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        attributeList: Attribute<AttributeId[], never>;
        clusterRevision: Attribute<number, never>;
        currentSensitivityLevel: WritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                sensitivityLevel: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        defaultSensitivityLevel: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                sensitivityLevel: boolean;
            }];
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
            generalFault: BitFlag;
        }>, any>;
        supportedSensitivityLevels: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                sensitivityLevel: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        enableDisableAlarm: Command<TypeFromFields<{
            alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        suppressAlarm: Command<TypeFromFields<{
            alarmsToSuppress: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                alarmSuppress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        alarmsStateChanged: Event<TypeFromFields<{
            alarmsActive: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
            alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        sensorFault: OptionalEvent<TypeFromFields<{
            sensorFault: FieldType<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>>;
        }>, any>;
    };
    features: {
        alarmSuppress: BitFlag;
        audible: BitFlag;
        sensitivityLevel: BitFlag;
        visual: BitFlag;
    };
    id: Branded<128, "ClusterId">;
    name: "BooleanStateConfiguration";
    revision: 1;
}>, ValuesT>
Inherited from Identity.set
- Defined in packages/types/src/cluster/mutation/MutableCluster.ts:89

with

with<const SelectionT>(...selection): Of<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        alarmsActive: Attribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
        };
        alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                alarmSuppress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        attributeList: Attribute<AttributeId[], never>;
        clusterRevision: Attribute<number, never>;
        currentSensitivityLevel: WritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                sensitivityLevel: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        defaultSensitivityLevel: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                sensitivityLevel: boolean;
            }];
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
            generalFault: BitFlag;
        }>, any>;
        supportedSensitivityLevels: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                sensitivityLevel: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        enableDisableAlarm: Command<TypeFromFields<{
            alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        suppressAlarm: Command<TypeFromFields<{
            alarmsToSuppress: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                alarmSuppress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        alarmsStateChanged: Event<TypeFromFields<{
            alarmsActive: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
            alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        sensorFault: OptionalEvent<TypeFromFields<{
            sensorFault: FieldType<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>>;
        }>, any>;
    };
    features: {
        alarmSuppress: BitFlag;
        audible: BitFlag;
        sensitivityLevel: BitFlag;
        visual: BitFlag;
    };
    id: Branded<128, "ClusterId">;
    name: "BooleanStateConfiguration";
    revision: 1;
}>, SelectionT>
Select features using ClusterComposer.compose.
Type Parameters
- const SelectionT extends FeatureSelection<Of<{
      attributes: {
          acceptedCommandList: Attribute<CommandId[], never>;
          alarmsActive: Attribute<TypeFromPartialBitSchema<{
              audible: BitFlag;
              visual: BitFlag;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  visual: boolean;
              }, {
                  audible: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
              audible: BitFlag;
              visual: BitFlag;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  visual: boolean;
              }, {
                  audible: boolean;
              }];
          };
          alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
              audible: BitFlag;
              visual: BitFlag;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  visual: boolean;
              }, {
                  audible: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
              audible: BitFlag;
              visual: BitFlag;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  alarmSuppress: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          attributeList: Attribute<AttributeId[], never>;
          clusterRevision: Attribute<number, never>;
          currentSensitivityLevel: WritableAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  sensitivityLevel: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          defaultSensitivityLevel: OptionalFixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  sensitivityLevel: boolean;
              }];
          };
          featureMap: Attribute<TypeFromPartialBitSchema<{
              alarmSuppress: BitFlag;
              audible: BitFlag;
              sensitivityLevel: BitFlag;
              visual: BitFlag;
          }>, never>;
          generatedCommandList: Attribute<CommandId[], never>;
          sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
              generalFault: BitFlag;
          }>, any>;
          supportedSensitivityLevels: FixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  sensitivityLevel: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      commands: {
          enableDisableAlarm: Command<TypeFromFields<{
              alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
                  audible: ...;
                  visual: ...;
              }>>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  visual: boolean;
              }, {
                  audible: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          suppressAlarm: Command<TypeFromFields<{
              alarmsToSuppress: FieldType<TypeFromPartialBitSchema<{
                  audible: ...;
                  visual: ...;
              }>>;
          }>, void, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  alarmSuppress: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
      };
      events: {
          alarmsStateChanged: Event<TypeFromFields<{
              alarmsActive: FieldType<TypeFromPartialBitSchema<{
                  audible: ...;
                  visual: ...;
              }>>;
              alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
                  audible: ...;
                  visual: ...;
              }>>;
          }>, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  visual: boolean;
              }, {
                  audible: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          sensorFault: OptionalEvent<TypeFromFields<{
              sensorFault: FieldType<TypeFromPartialBitSchema<{
                  generalFault: BitFlag;
              }>>;
          }>, any>;
      };
      features: {
          alarmSuppress: BitFlag;
          audible: BitFlag;
          sensitivityLevel: BitFlag;
          visual: BitFlag;
      };
      id: Branded<128, "ClusterId">;
      name: "BooleanStateConfiguration";
      revision: 1;
  }>>
Parameters
- Rest...selection: SelectionT
Returns Of<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        alarmsActive: Attribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
        };
        alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
            audible: BitFlag;
            visual: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                alarmSuppress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        attributeList: Attribute<AttributeId[], never>;
        clusterRevision: Attribute<number, never>;
        currentSensitivityLevel: WritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                sensitivityLevel: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        defaultSensitivityLevel: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                sensitivityLevel: boolean;
            }];
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
            generalFault: BitFlag;
        }>, any>;
        supportedSensitivityLevels: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                sensitivityLevel: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    commands: {
        enableDisableAlarm: Command<TypeFromFields<{
            alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        suppressAlarm: Command<TypeFromFields<{
            alarmsToSuppress: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                alarmSuppress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    events: {
        alarmsStateChanged: Event<TypeFromFields<{
            alarmsActive: FieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
            alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
                audible: ...;
                visual: ...;
            }>>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                visual: boolean;
            }, {
                audible: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        sensorFault: OptionalEvent<TypeFromFields<{
            sensorFault: FieldType<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>>;
        }>, any>;
    };
    features: {
        alarmSuppress: BitFlag;
        audible: BitFlag;
        sensitivityLevel: BitFlag;
        visual: BitFlag;
    };
    id: Branded<128, "ClusterId">;
    name: "BooleanStateConfiguration";
    revision: 1;
}>, SelectionT>
Inherited from Identity.with
- Defined in packages/types/src/cluster/mutation/MutableCluster.ts:75

Interface Complete

Hierarchy (view full)

Index

Properties

Methods

Properties

attributes

Type declaration

ReadonlyacceptedCommandList: Attribute<CommandId[], never>

ReadonlyalarmsActive: Attribute<TypeFromPartialBitSchema<{ audible: BitFlag; visual: BitFlag; }>, any> & { isConditional: true; mandatoryIf: [] | [{ visual: boolean; }, { audible: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

ReadonlyalarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{ audible: BitFlag; visual: BitFlag; }>, any> & { isConditional: true; mandatoryIf: [] | ConditionalFeatureList<BitSchema>; optional: true; optionalIf: [] | [{ visual: boolean; }, { audible: boolean; }]; }

ReadonlyalarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{ audible: BitFlag; visual: BitFlag; }>, any> & { isConditional: true; mandatoryIf: [] | [{ visual: boolean; }, { audible: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

ReadonlyalarmsSuppressed: Attribute<TypeFromPartialBitSchema<{ audible: BitFlag; visual: BitFlag; }>, any> & { isConditional: true; mandatoryIf: [] | [{ alarmSuppress: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

ReadonlyattributeList: Attribute<AttributeId[], never>

ReadonlyclusterRevision: Attribute<number, never>

ReadonlycurrentSensitivityLevel: WritableAttribute<number, any> & { isConditional: true; mandatoryIf: [] | [{ sensitivityLevel: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

ReadonlydefaultSensitivityLevel: OptionalFixedAttribute<number, any> & { isConditional: true; mandatoryIf: [] | ConditionalFeatureList<BitSchema>; optional: true; optionalIf: [] | [{ sensitivityLevel: boolean; }]; }

ReadonlyfeatureMap: Attribute<TypeFromPartialBitSchema<{ alarmSuppress: BitFlag; audible: BitFlag; sensitivityLevel: BitFlag; visual: BitFlag; }>, never>

ReadonlygeneratedCommandList: Attribute<CommandId[], never>

ReadonlysensorFault: OptionalAttribute<TypeFromPartialBitSchema<{ generalFault: BitFlag; }>, any>

See

ReadonlysupportedSensitivityLevels: FixedAttribute<number, any> & { isConditional: true; mandatoryIf: [] | [{ sensitivityLevel: boolean; }]; optional: true; optionalIf: [] | ConditionalFeatureList<BitSchema>; }

base

commands

events

Type declaration

ReadonlysensorFault: OptionalEvent<TypeFromFields<{ sensorFault: FieldType<TypeFromPartialBitSchema<{ generalFault: BitFlag; }>>; }>, any>

See

extensions

features

Type declaration

ReadonlyalarmSuppress: BitFlag

See

Readonlyaudible: BitFlag

ReadonlysensitivityLevel: BitFlag

Readonlyvisual: BitFlag

id

name

revision

supportedFeatures

unknown

Methods

alter

Type Parameters

Parameters

enable

Type Parameters

Parameters

set

Type Parameters

Parameters

with

Type Parameters

Parameters

Settings

On This Page

`Readonly`acceptedCommandList: Attribute<CommandId[], never>

`Readonly`alarmsActive: Attribute<TypeFromPartialBitSchema<{
audible: BitFlag;
visual: BitFlag;
}>, any> & {
isConditional: true;
mandatoryIf: [] | [{
visual: boolean;
}, {
audible: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
audible: BitFlag;
visual: BitFlag;
}>, any> & {
isConditional: true;
mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
optional: true;
optionalIf: [] | [{
visual: boolean;
}, {
audible: boolean;
}];
}

`Readonly`alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
audible: BitFlag;
visual: BitFlag;
}>, any> & {
isConditional: true;
mandatoryIf: [] | [{
visual: boolean;
}, {
audible: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
audible: BitFlag;
visual: BitFlag;
}>, any> & {
isConditional: true;
mandatoryIf: [] | [{
alarmSuppress: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`attributeList: Attribute<AttributeId[], never>

`Readonly`clusterRevision: Attribute<number, never>

`Readonly`currentSensitivityLevel: WritableAttribute<number, any> & {
isConditional: true;
mandatoryIf: [] | [{
sensitivityLevel: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`defaultSensitivityLevel: OptionalFixedAttribute<number, any> & {
isConditional: true;
mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
optional: true;
optionalIf: [] | [{
sensitivityLevel: boolean;
}];
}

`Readonly`featureMap: Attribute<TypeFromPartialBitSchema<{
alarmSuppress: BitFlag;
audible: BitFlag;
sensitivityLevel: BitFlag;
visual: BitFlag;
}>, never>

`Readonly`generatedCommandList: Attribute<CommandId[], never>

`Readonly`sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
generalFault: BitFlag;
}>, any>

`Readonly`supportedSensitivityLevels: FixedAttribute<number, any> & {
isConditional: true;
mandatoryIf: [] | [{
sensitivityLevel: boolean;
}];
optional: true;
optionalIf: [] | ConditionalFeatureList<BitSchema>;
}

`Readonly`sensorFault: OptionalEvent<TypeFromFields<{
sensorFault: FieldType<TypeFromPartialBitSchema<{
generalFault: BitFlag;
}>>;
}>, any>

`Readonly`alarmSuppress: BitFlag

`Readonly`audible: BitFlag

`Readonly`sensitivityLevel: BitFlag

`Readonly`visual: BitFlag