Interface Cluster

This cluster is used to configure a boolean sensor, including optional state change alarm features and configuration of the sensitivity level associated with the sensor.

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

See

MatterSpecification.v13.Cluster § 1.8

interface Cluster {
    attributes: Merge<{
        sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
            generalFault: BitFlag;
        }>, any>;
    }, GlobalAttributes<{
        alarmSuppress: BitFlag;
        audible: BitFlag;
        sensitivityLevel: BitFlag;
        visual: BitFlag;
    }>>;
    base: undefined;
    commands: {};
    events: {
        sensorFault: OptionalEvent<TypeFromFields<{
            sensorFault: FieldType<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>>;
        }>, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                currentSensitivityLevel: WritableAttribute<number, any>;
                defaultSensitivityLevel: OptionalFixedAttribute<number, any>;
                supportedSensitivityLevels: FixedAttribute<number, any>;
            };
        };
        flags: {
            sensitivityLevel: true;
        };
    }, {
        component: {
            attributes: {
                alarmsActive: Attribute<TypeFromPartialBitSchema<{
                    audible: BitFlag;
                    visual: BitFlag;
                }>, any>;
                alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                    audible: BitFlag;
                    visual: BitFlag;
                }>, any>;
                alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                    audible: BitFlag;
                    visual: BitFlag;
                }>, any>;
            };
            commands: {
                enableDisableAlarm: Command<TypeFromFields<{
                    alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>>;
                }>, void, any>;
            };
            events: {
                alarmsStateChanged: Event<TypeFromFields<{
                    alarmsActive: FieldType<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>>;
                    alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>>;
                }>, any>;
            };
        };
        flags: {
            visual: true;
        };
    }, {
        component: {
            attributes: {
                alarmsActive: Attribute<TypeFromPartialBitSchema<{
                    audible: BitFlag;
                    visual: BitFlag;
                }>, any>;
                alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                    audible: BitFlag;
                    visual: BitFlag;
                }>, any>;
                alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                    audible: BitFlag;
                    visual: BitFlag;
                }>, any>;
            };
            commands: {
                enableDisableAlarm: Command<TypeFromFields<{
                    alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>>;
                }>, void, any>;
            };
            events: {
                alarmsStateChanged: Event<TypeFromFields<{
                    alarmsActive: FieldType<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>>;
                    alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>>;
                }>, any>;
            };
        };
        flags: {
            audible: true;
        };
    }, {
        component: {
            attributes: {
                alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                    audible: BitFlag;
                    visual: BitFlag;
                }>, any>;
            };
            commands: {
                suppressAlarm: Command<TypeFromFields<{
                    alarmsToSuppress: FieldType<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>>;
                }>, void, any>;
            };
        };
        flags: {
            alarmSuppress: true;
        };
    }, {
        component: false;
        flags: {
            alarmSuppress: true;
            audible: true;
            visual: true;
        };
    }];
    features: {
        alarmSuppress: BitFlag;
        audible: BitFlag;
        sensitivityLevel: BitFlag;
        visual: BitFlag;
    };
    id: Branded<128, "ClusterId">;
    name: "BooleanStateConfiguration";
    revision: 1;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>, any>;
        };
        events: {
            sensorFault: OptionalEvent<TypeFromFields<{
                sensorFault: FieldType<TypeFromPartialBitSchema<{
                    generalFault: BitFlag;
                }>>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentSensitivityLevel: WritableAttribute<number, any>;
                    defaultSensitivityLevel: OptionalFixedAttribute<number, any>;
                    supportedSensitivityLevels: FixedAttribute<number, any>;
                };
            };
            flags: {
                sensitivityLevel: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                visual: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                audible: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    suppressAlarm: Command<TypeFromFields<{
                        alarmsToSuppress: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                alarmSuppress: true;
            };
        }, {
            component: false;
            flags: {
                alarmSuppress: true;
                audible: true;
                visual: true;
            };
        }];
        features: {
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        };
        id: 128;
        name: "BooleanStateConfiguration";
        revision: 1;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>, any>;
        };
        events: {
            sensorFault: OptionalEvent<TypeFromFields<{
                sensorFault: FieldType<TypeFromPartialBitSchema<{
                    generalFault: BitFlag;
                }>>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentSensitivityLevel: WritableAttribute<number, any>;
                    defaultSensitivityLevel: OptionalFixedAttribute<number, any>;
                    supportedSensitivityLevels: FixedAttribute<number, any>;
                };
            };
            flags: {
                sensitivityLevel: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                visual: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                audible: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    suppressAlarm: Command<TypeFromFields<{
                        alarmsToSuppress: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                alarmSuppress: true;
            };
        }, {
            component: false;
            flags: {
                alarmSuppress: true;
                audible: true;
                visual: true;
            };
        }];
        features: {
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        };
        id: 128;
        name: "BooleanStateConfiguration";
        revision: 1;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>, any>;
        };
        events: {
            sensorFault: OptionalEvent<TypeFromFields<{
                sensorFault: FieldType<TypeFromPartialBitSchema<{
                    generalFault: BitFlag;
                }>>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentSensitivityLevel: WritableAttribute<number, any>;
                    defaultSensitivityLevel: OptionalFixedAttribute<number, any>;
                    supportedSensitivityLevels: FixedAttribute<number, any>;
                };
            };
            flags: {
                sensitivityLevel: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                visual: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                audible: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    suppressAlarm: Command<TypeFromFields<{
                        alarmsToSuppress: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                alarmSuppress: true;
            };
        }, {
            component: false;
            flags: {
                alarmSuppress: true;
                audible: true;
                visual: true;
            };
        }];
        features: {
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        };
        id: 128;
        name: "BooleanStateConfiguration";
        revision: 1;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>, any>;
        };
        events: {
            sensorFault: OptionalEvent<TypeFromFields<{
                sensorFault: FieldType<TypeFromPartialBitSchema<{
                    generalFault: BitFlag;
                }>>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentSensitivityLevel: WritableAttribute<number, any>;
                    defaultSensitivityLevel: OptionalFixedAttribute<number, any>;
                    supportedSensitivityLevels: FixedAttribute<number, any>;
                };
            };
            flags: {
                sensitivityLevel: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                visual: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                audible: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    suppressAlarm: Command<TypeFromFields<{
                        alarmsToSuppress: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                alarmSuppress: true;
            };
        }, {
            component: false;
            flags: {
                alarmSuppress: true;
                audible: true;
                visual: true;
            };
        }];
        features: {
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        };
        id: 128;
        name: "BooleanStateConfiguration";
        revision: 1;
    }>, SelectionT>;
}

Hierarchy (view full)

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
        generalFault: BitFlag;
    }>, any>;
}, GlobalAttributes<{
    alarmSuppress: BitFlag;
    audible: BitFlag;
    sensitivityLevel: BitFlag;
    visual: BitFlag;
}>>

Type declaration

base

base: undefined

commands

commands: {}

events

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

Type declaration

extensions

extensions: readonly [{
    component: {
        attributes: {
            currentSensitivityLevel: WritableAttribute<number, any>;
            defaultSensitivityLevel: OptionalFixedAttribute<number, any>;
            supportedSensitivityLevels: FixedAttribute<number, any>;
        };
    };
    flags: {
        sensitivityLevel: true;
    };
}, {
    component: {
        attributes: {
            alarmsActive: Attribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any>;
            alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any>;
            alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any>;
        };
        commands: {
            enableDisableAlarm: Command<TypeFromFields<{
                alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
                    audible: BitFlag;
                    visual: BitFlag;
                }>>;
            }>, void, any>;
        };
        events: {
            alarmsStateChanged: Event<TypeFromFields<{
                alarmsActive: FieldType<TypeFromPartialBitSchema<{
                    audible: BitFlag;
                    visual: BitFlag;
                }>>;
                alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
                    audible: BitFlag;
                    visual: BitFlag;
                }>>;
            }>, any>;
        };
    };
    flags: {
        visual: true;
    };
}, {
    component: {
        attributes: {
            alarmsActive: Attribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any>;
            alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any>;
            alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any>;
        };
        commands: {
            enableDisableAlarm: Command<TypeFromFields<{
                alarmsToEnableDisable: FieldType<TypeFromPartialBitSchema<{
                    audible: BitFlag;
                    visual: BitFlag;
                }>>;
            }>, void, any>;
        };
        events: {
            alarmsStateChanged: Event<TypeFromFields<{
                alarmsActive: FieldType<TypeFromPartialBitSchema<{
                    audible: BitFlag;
                    visual: BitFlag;
                }>>;
                alarmsSuppressed: OptionalFieldType<TypeFromPartialBitSchema<{
                    audible: BitFlag;
                    visual: BitFlag;
                }>>;
            }>, any>;
        };
    };
    flags: {
        audible: true;
    };
}, {
    component: {
        attributes: {
            alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                audible: BitFlag;
                visual: BitFlag;
            }>, any>;
        };
        commands: {
            suppressAlarm: Command<TypeFromFields<{
                alarmsToSuppress: FieldType<TypeFromPartialBitSchema<{
                    audible: BitFlag;
                    visual: BitFlag;
                }>>;
            }>, void, any>;
        };
    };
    flags: {
        alarmSuppress: true;
    };
}, {
    component: false;
    flags: {
        alarmSuppress: true;
        audible: true;
        visual: true;
    };
}]

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

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>, any>;
        };
        events: {
            sensorFault: OptionalEvent<TypeFromFields<{
                sensorFault: FieldType<TypeFromPartialBitSchema<{
                    generalFault: BitFlag;
                }>>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentSensitivityLevel: WritableAttribute<number, any>;
                    defaultSensitivityLevel: OptionalFixedAttribute<number, any>;
                    supportedSensitivityLevels: FixedAttribute<number, any>;
                };
            };
            flags: {
                sensitivityLevel: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                visual: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                audible: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    suppressAlarm: Command<TypeFromFields<{
                        alarmsToSuppress: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                alarmSuppress: true;
            };
        }, {
            component: false;
            flags: {
                alarmSuppress: true;
                audible: true;
                visual: true;
            };
        }];
        features: {
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        };
        id: 128;
        name: "BooleanStateConfiguration";
        revision: 1;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
                  generalFault: BitFlag;
              }>, any>;
          };
          events: {
              sensorFault: OptionalEvent<TypeFromFields<{
                  sensorFault: FieldType<TypeFromPartialBitSchema<{
                      generalFault: BitFlag;
                  }>>;
              }>, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      currentSensitivityLevel: WritableAttribute<number, any>;
                      defaultSensitivityLevel: OptionalFixedAttribute<number, any>;
                      supportedSensitivityLevels: FixedAttribute<number, any>;
                  };
              };
              flags: {
                  sensitivityLevel: true;
              };
          }, {
              component: {
                  attributes: {
                      alarmsActive: Attribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                      alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                      alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                  };
                  commands: {
                      enableDisableAlarm: Command<TypeFromFields<{
                          alarmsToEnableDisable: FieldType<(...)>;
                      }>, void, any>;
                  };
                  events: {
                      alarmsStateChanged: Event<TypeFromFields<{
                          alarmsActive: FieldType<(...)>;
                          alarmsSuppressed: OptionalFieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  visual: true;
              };
          }, {
              component: {
                  attributes: {
                      alarmsActive: Attribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                      alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                      alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                  };
                  commands: {
                      enableDisableAlarm: Command<TypeFromFields<{
                          alarmsToEnableDisable: FieldType<(...)>;
                      }>, void, any>;
                  };
                  events: {
                      alarmsStateChanged: Event<TypeFromFields<{
                          alarmsActive: FieldType<(...)>;
                          alarmsSuppressed: OptionalFieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  audible: true;
              };
          }, {
              component: {
                  attributes: {
                      alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                  };
                  commands: {
                      suppressAlarm: Command<TypeFromFields<{
                          alarmsToSuppress: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  alarmSuppress: true;
              };
          }, {
              component: false;
              flags: {
                  alarmSuppress: true;
                  audible: true;
                  visual: true;
              };
          }];
          features: {
              alarmSuppress: BitFlag;
              audible: BitFlag;
              sensitivityLevel: BitFlag;
              visual: BitFlag;
          };
          id: 128;
          name: "BooleanStateConfiguration";
          revision: 1;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>, any>;
        };
        events: {
            sensorFault: OptionalEvent<TypeFromFields<{
                sensorFault: FieldType<TypeFromPartialBitSchema<{
                    generalFault: BitFlag;
                }>>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentSensitivityLevel: WritableAttribute<number, any>;
                    defaultSensitivityLevel: OptionalFixedAttribute<number, any>;
                    supportedSensitivityLevels: FixedAttribute<number, any>;
                };
            };
            flags: {
                sensitivityLevel: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                visual: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                audible: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    suppressAlarm: Command<TypeFromFields<{
                        alarmsToSuppress: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                alarmSuppress: true;
            };
        }, {
            component: false;
            flags: {
                alarmSuppress: true;
                audible: true;
                visual: true;
            };
        }];
        features: {
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        };
        id: 128;
        name: "BooleanStateConfiguration";
        revision: 1;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>, any>;
        };
        events: {
            sensorFault: OptionalEvent<TypeFromFields<{
                sensorFault: FieldType<TypeFromPartialBitSchema<{
                    generalFault: BitFlag;
                }>>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentSensitivityLevel: WritableAttribute<number, any>;
                    defaultSensitivityLevel: OptionalFixedAttribute<number, any>;
                    supportedSensitivityLevels: FixedAttribute<number, any>;
                };
            };
            flags: {
                sensitivityLevel: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                visual: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                audible: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    suppressAlarm: Command<TypeFromFields<{
                        alarmsToSuppress: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                alarmSuppress: true;
            };
        }, {
            component: false;
            flags: {
                alarmSuppress: true;
                audible: true;
                visual: true;
            };
        }];
        features: {
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        };
        id: 128;
        name: "BooleanStateConfiguration";
        revision: 1;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
                  generalFault: BitFlag;
              }>, any>;
          };
          events: {
              sensorFault: OptionalEvent<TypeFromFields<{
                  sensorFault: FieldType<TypeFromPartialBitSchema<{
                      generalFault: BitFlag;
                  }>>;
              }>, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      currentSensitivityLevel: WritableAttribute<number, any>;
                      defaultSensitivityLevel: OptionalFixedAttribute<number, any>;
                      supportedSensitivityLevels: FixedAttribute<number, any>;
                  };
              };
              flags: {
                  sensitivityLevel: true;
              };
          }, {
              component: {
                  attributes: {
                      alarmsActive: Attribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                      alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                      alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                  };
                  commands: {
                      enableDisableAlarm: Command<TypeFromFields<{
                          alarmsToEnableDisable: FieldType<(...)>;
                      }>, void, any>;
                  };
                  events: {
                      alarmsStateChanged: Event<TypeFromFields<{
                          alarmsActive: FieldType<(...)>;
                          alarmsSuppressed: OptionalFieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  visual: true;
              };
          }, {
              component: {
                  attributes: {
                      alarmsActive: Attribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                      alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                      alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                  };
                  commands: {
                      enableDisableAlarm: Command<TypeFromFields<{
                          alarmsToEnableDisable: FieldType<(...)>;
                      }>, void, any>;
                  };
                  events: {
                      alarmsStateChanged: Event<TypeFromFields<{
                          alarmsActive: FieldType<(...)>;
                          alarmsSuppressed: OptionalFieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  audible: true;
              };
          }, {
              component: {
                  attributes: {
                      alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                  };
                  commands: {
                      suppressAlarm: Command<TypeFromFields<{
                          alarmsToSuppress: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  alarmSuppress: true;
              };
          }, {
              component: false;
              flags: {
                  alarmSuppress: true;
                  audible: true;
                  visual: true;
              };
          }];
          features: {
              alarmSuppress: BitFlag;
              audible: BitFlag;
              sensitivityLevel: BitFlag;
              visual: BitFlag;
          };
          id: 128;
          name: "BooleanStateConfiguration";
          revision: 1;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>, any>;
        };
        events: {
            sensorFault: OptionalEvent<TypeFromFields<{
                sensorFault: FieldType<TypeFromPartialBitSchema<{
                    generalFault: BitFlag;
                }>>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentSensitivityLevel: WritableAttribute<number, any>;
                    defaultSensitivityLevel: OptionalFixedAttribute<number, any>;
                    supportedSensitivityLevels: FixedAttribute<number, any>;
                };
            };
            flags: {
                sensitivityLevel: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                visual: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                audible: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    suppressAlarm: Command<TypeFromFields<{
                        alarmsToSuppress: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                alarmSuppress: true;
            };
        }, {
            component: false;
            flags: {
                alarmSuppress: true;
                audible: true;
                visual: true;
            };
        }];
        features: {
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        };
        id: 128;
        name: "BooleanStateConfiguration";
        revision: 1;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>, any>;
        };
        events: {
            sensorFault: OptionalEvent<TypeFromFields<{
                sensorFault: FieldType<TypeFromPartialBitSchema<{
                    generalFault: BitFlag;
                }>>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentSensitivityLevel: WritableAttribute<number, any>;
                    defaultSensitivityLevel: OptionalFixedAttribute<number, any>;
                    supportedSensitivityLevels: FixedAttribute<number, any>;
                };
            };
            flags: {
                sensitivityLevel: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                visual: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                audible: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    suppressAlarm: Command<TypeFromFields<{
                        alarmsToSuppress: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                alarmSuppress: true;
            };
        }, {
            component: false;
            flags: {
                alarmSuppress: true;
                audible: true;
                visual: true;
            };
        }];
        features: {
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        };
        id: 128;
        name: "BooleanStateConfiguration";
        revision: 1;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          sensorFault?: {
              generalFault?: boolean;
          };
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>, any>;
        };
        events: {
            sensorFault: OptionalEvent<TypeFromFields<{
                sensorFault: FieldType<TypeFromPartialBitSchema<{
                    generalFault: BitFlag;
                }>>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentSensitivityLevel: WritableAttribute<number, any>;
                    defaultSensitivityLevel: OptionalFixedAttribute<number, any>;
                    supportedSensitivityLevels: FixedAttribute<number, any>;
                };
            };
            flags: {
                sensitivityLevel: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                visual: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                audible: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    suppressAlarm: Command<TypeFromFields<{
                        alarmsToSuppress: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                alarmSuppress: true;
            };
        }, {
            component: false;
            flags: {
                alarmSuppress: true;
                audible: true;
                visual: true;
            };
        }];
        features: {
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        };
        id: 128;
        name: "BooleanStateConfiguration";
        revision: 1;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>, any>;
        };
        events: {
            sensorFault: OptionalEvent<TypeFromFields<{
                sensorFault: FieldType<TypeFromPartialBitSchema<{
                    generalFault: BitFlag;
                }>>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentSensitivityLevel: WritableAttribute<number, any>;
                    defaultSensitivityLevel: OptionalFixedAttribute<number, any>;
                    supportedSensitivityLevels: FixedAttribute<number, any>;
                };
            };
            flags: {
                sensitivityLevel: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                visual: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                audible: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    suppressAlarm: Command<TypeFromFields<{
                        alarmsToSuppress: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                alarmSuppress: true;
            };
        }, {
            component: false;
            flags: {
                alarmSuppress: true;
                audible: true;
                visual: true;
            };
        }];
        features: {
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        };
        id: 128;
        name: "BooleanStateConfiguration";
        revision: 1;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
                  generalFault: BitFlag;
              }>, any>;
          };
          events: {
              sensorFault: OptionalEvent<TypeFromFields<{
                  sensorFault: FieldType<TypeFromPartialBitSchema<{
                      generalFault: BitFlag;
                  }>>;
              }>, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      currentSensitivityLevel: WritableAttribute<number, any>;
                      defaultSensitivityLevel: OptionalFixedAttribute<number, any>;
                      supportedSensitivityLevels: FixedAttribute<number, any>;
                  };
              };
              flags: {
                  sensitivityLevel: true;
              };
          }, {
              component: {
                  attributes: {
                      alarmsActive: Attribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                      alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                      alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                  };
                  commands: {
                      enableDisableAlarm: Command<TypeFromFields<{
                          alarmsToEnableDisable: FieldType<(...)>;
                      }>, void, any>;
                  };
                  events: {
                      alarmsStateChanged: Event<TypeFromFields<{
                          alarmsActive: FieldType<(...)>;
                          alarmsSuppressed: OptionalFieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  visual: true;
              };
          }, {
              component: {
                  attributes: {
                      alarmsActive: Attribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                      alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                      alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                  };
                  commands: {
                      enableDisableAlarm: Command<TypeFromFields<{
                          alarmsToEnableDisable: FieldType<(...)>;
                      }>, void, any>;
                  };
                  events: {
                      alarmsStateChanged: Event<TypeFromFields<{
                          alarmsActive: FieldType<(...)>;
                          alarmsSuppressed: OptionalFieldType<(...)>;
                      }>, any>;
                  };
              };
              flags: {
                  audible: true;
              };
          }, {
              component: {
                  attributes: {
                      alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                          audible: BitFlag;
                          visual: BitFlag;
                      }>, any>;
                  };
                  commands: {
                      suppressAlarm: Command<TypeFromFields<{
                          alarmsToSuppress: FieldType<(...)>;
                      }>, void, any>;
                  };
              };
              flags: {
                  alarmSuppress: true;
              };
          }, {
              component: false;
              flags: {
                  alarmSuppress: true;
                  audible: true;
                  visual: true;
              };
          }];
          features: {
              alarmSuppress: BitFlag;
              audible: BitFlag;
              sensitivityLevel: BitFlag;
              visual: BitFlag;
          };
          id: 128;
          name: "BooleanStateConfiguration";
          revision: 1;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            sensorFault: OptionalAttribute<TypeFromPartialBitSchema<{
                generalFault: BitFlag;
            }>, any>;
        };
        events: {
            sensorFault: OptionalEvent<TypeFromFields<{
                sensorFault: FieldType<TypeFromPartialBitSchema<{
                    generalFault: BitFlag;
                }>>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentSensitivityLevel: WritableAttribute<number, any>;
                    defaultSensitivityLevel: OptionalFixedAttribute<number, any>;
                    supportedSensitivityLevels: FixedAttribute<number, any>;
                };
            };
            flags: {
                sensitivityLevel: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                visual: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsActive: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsEnabled: OptionalAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                    alarmsSupported: FixedAttribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    enableDisableAlarm: Command<TypeFromFields<{
                        alarmsToEnableDisable: FieldType<(...)>;
                    }>, void, any>;
                };
                events: {
                    alarmsStateChanged: Event<TypeFromFields<{
                        alarmsActive: FieldType<(...)>;
                        alarmsSuppressed: OptionalFieldType<(...)>;
                    }>, any>;
                };
            };
            flags: {
                audible: true;
            };
        }, {
            component: {
                attributes: {
                    alarmsSuppressed: Attribute<TypeFromPartialBitSchema<{
                        audible: BitFlag;
                        visual: BitFlag;
                    }>, any>;
                };
                commands: {
                    suppressAlarm: Command<TypeFromFields<{
                        alarmsToSuppress: FieldType<(...)>;
                    }>, void, any>;
                };
            };
            flags: {
                alarmSuppress: true;
            };
        }, {
            component: false;
            flags: {
                alarmSuppress: true;
                audible: true;
                visual: true;
            };
        }];
        features: {
            alarmSuppress: BitFlag;
            audible: BitFlag;
            sensitivityLevel: BitFlag;
            visual: BitFlag;
        };
        id: 128;
        name: "BooleanStateConfiguration";
        revision: 1;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods