Variable CompleteInstanceConst

Type declaration

• Readonlyattributes: {
      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>;
      };
  }

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

• Readonlycommands: {
      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>;
      };
  }

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

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

• Readonlyevents: {
      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>;
  }

  • 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

• Readonlyfeatures: {
      alarmSuppress: BitFlag;
      audible: BitFlag;
      sensitivityLevel: BitFlag;
      visual: BitFlag;
  }

  • 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

• Readonlyid: Branded<128, "ClusterId">

• Readonlyname: "BooleanStateConfiguration"

• Readonlyrevision: 1