Interface Complete

This cluster supports all PressureMeasurement 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>;
        attributeList: Attribute<AttributeId[], never>;
        clusterRevision: Attribute<number, never>;
        featureMap: Attribute<TypeFromPartialBitSchema<{
            extended: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        maxMeasuredValue: Attribute<null | number, any>;
        maxScaledValue: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                extended: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        measuredValue: Attribute<null | number, any>;
        minMeasuredValue: Attribute<null | number, any>;
        minScaledValue: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                extended: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        scale: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                extended: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        scaledTolerance: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                extended: boolean;
            }];
        };
        scaledValue: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                extended: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        tolerance: OptionalAttribute<number, any>;
    }, GlobalAttributes<{
        extended: BitFlag;
    }>>;
    base: undefined;
    commands: {};
    events: {};
    extensions: undefined;
    features: {
        extended: BitFlag;
    };
    id: Branded<Branded<1027, "ClusterId">, "ClusterId">;
    name: "PressureMeasurement";
    revision: 3;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                extended: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxMeasuredValue: Attribute<null | number, any>;
            maxScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any>;
            minMeasuredValue: Attribute<null | number, any>;
            minScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scale: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scaledTolerance: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    extended: boolean;
                }];
            };
            scaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            tolerance: OptionalAttribute<number, any>;
        };
        features: {
            extended: BitFlag;
        };
        id: Branded<1027, "ClusterId">;
        name: "PressureMeasurement";
        revision: 3;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                extended: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxMeasuredValue: Attribute<null | number, any>;
            maxScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any>;
            minMeasuredValue: Attribute<null | number, any>;
            minScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scale: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scaledTolerance: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    extended: boolean;
                }];
            };
            scaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            tolerance: OptionalAttribute<number, any>;
        };
        features: {
            extended: BitFlag;
        };
        id: Branded<1027, "ClusterId">;
        name: "PressureMeasurement";
        revision: 3;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                extended: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxMeasuredValue: Attribute<null | number, any>;
            maxScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any>;
            minMeasuredValue: Attribute<null | number, any>;
            minScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scale: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scaledTolerance: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    extended: boolean;
                }];
            };
            scaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            tolerance: OptionalAttribute<number, any>;
        };
        features: {
            extended: BitFlag;
        };
        id: Branded<1027, "ClusterId">;
        name: "PressureMeasurement";
        revision: 3;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                extended: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxMeasuredValue: Attribute<null | number, any>;
            maxScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any>;
            minMeasuredValue: Attribute<null | number, any>;
            minScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scale: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scaledTolerance: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    extended: boolean;
                }];
            };
            scaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            tolerance: OptionalAttribute<number, any>;
        };
        features: {
            extended: BitFlag;
        };
        id: Branded<1027, "ClusterId">;
        name: "PressureMeasurement";
        revision: 3;
    }>, SelectionT>;
}

Hierarchy (view full)

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    acceptedCommandList: Attribute<CommandId[], never>;
    attributeList: Attribute<AttributeId[], never>;
    clusterRevision: Attribute<number, never>;
    featureMap: Attribute<TypeFromPartialBitSchema<{
        extended: BitFlag;
    }>, never>;
    generatedCommandList: Attribute<CommandId[], never>;
    maxMeasuredValue: Attribute<null | number, any>;
    maxScaledValue: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            extended: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    measuredValue: Attribute<null | number, any>;
    minMeasuredValue: Attribute<null | number, any>;
    minScaledValue: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            extended: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    scale: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            extended: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    scaledTolerance: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            extended: boolean;
        }];
    };
    scaledValue: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            extended: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    tolerance: OptionalAttribute<number, any>;
}, GlobalAttributes<{
    extended: BitFlag;
}>>

Type declaration

  • ReadonlyacceptedCommandList: Attribute<CommandId[], never>

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

  • 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.

  • ReadonlyfeatureMap: Attribute<TypeFromPartialBitSchema<{
        extended: 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).

  • ReadonlymaxMeasuredValue: Attribute<null | number, any>

    Indicates the maximum value of MeasuredValue that can be measured. See Measured Value for more details.

    The null value indicates that the value is not available.

    See

    MatterSpecification.v13.Cluster § 2.4.5.3

  • ReadonlymaxScaledValue: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            extended: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlymeasuredValue: Attribute<null | number, any>

    Indicates the pressure in kPa as follows:

    MeasuredValue = 10 x Pressure [kPa]

    The null value indicates that the value is not available.

    See

    MatterSpecification.v13.Cluster § 2.4.5.1

  • ReadonlyminMeasuredValue: Attribute<null | number, any>

    Indicates the minimum value of MeasuredValue that can be measured. See Measured Value for more details.

    The null value indicates that the value is not available.

    See

    MatterSpecification.v13.Cluster § 2.4.5.2

  • ReadonlyminScaledValue: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            extended: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • Readonlyscale: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            extended: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyscaledTolerance: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            extended: boolean;
        }];
    }
  • ReadonlyscaledValue: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            extended: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • Readonlytolerance: OptionalAttribute<number, any>

    See Measured Value.

    See

    MatterSpecification.v13.Cluster § 2.4.5.4

base

base: undefined

commands

commands: {}

events

events: {}

extensions

extensions: undefined

features

features: {
    extended: BitFlag;
}

Type declaration

  • Readonlyextended: BitFlag

    Extended

    Extended range and resolution

id

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

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                extended: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxMeasuredValue: Attribute<null | number, any>;
            maxScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any>;
            minMeasuredValue: Attribute<null | number, any>;
            minScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scale: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scaledTolerance: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    extended: boolean;
                }];
            };
            scaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            tolerance: OptionalAttribute<number, any>;
        };
        features: {
            extended: BitFlag;
        };
        id: Branded<1027, "ClusterId">;
        name: "PressureMeasurement";
        revision: 3;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              attributeList: Attribute<AttributeId[], never>;
              clusterRevision: Attribute<number, never>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  extended: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maxMeasuredValue: Attribute<null | number, any>;
              maxScaledValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      extended: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              measuredValue: Attribute<null | number, any>;
              minMeasuredValue: Attribute<null | number, any>;
              minScaledValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      extended: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              scale: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      extended: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              scaledTolerance: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      extended: boolean;
                  }];
              };
              scaledValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      extended: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              tolerance: OptionalAttribute<number, any>;
          };
          features: {
              extended: BitFlag;
          };
          id: Branded<1027, "ClusterId">;
          name: "PressureMeasurement";
          revision: 3;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                extended: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxMeasuredValue: Attribute<null | number, any>;
            maxScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any>;
            minMeasuredValue: Attribute<null | number, any>;
            minScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scale: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scaledTolerance: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    extended: boolean;
                }];
            };
            scaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            tolerance: OptionalAttribute<number, any>;
        };
        features: {
            extended: BitFlag;
        };
        id: Branded<1027, "ClusterId">;
        name: "PressureMeasurement";
        revision: 3;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                extended: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxMeasuredValue: Attribute<null | number, any>;
            maxScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any>;
            minMeasuredValue: Attribute<null | number, any>;
            minScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scale: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scaledTolerance: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    extended: boolean;
                }];
            };
            scaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            tolerance: OptionalAttribute<number, any>;
        };
        features: {
            extended: BitFlag;
        };
        id: Branded<1027, "ClusterId">;
        name: "PressureMeasurement";
        revision: 3;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              attributeList: Attribute<AttributeId[], never>;
              clusterRevision: Attribute<number, never>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  extended: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maxMeasuredValue: Attribute<null | number, any>;
              maxScaledValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      extended: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              measuredValue: Attribute<null | number, any>;
              minMeasuredValue: Attribute<null | number, any>;
              minScaledValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      extended: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              scale: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      extended: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              scaledTolerance: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      extended: boolean;
                  }];
              };
              scaledValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      extended: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              tolerance: OptionalAttribute<number, any>;
          };
          features: {
              extended: BitFlag;
          };
          id: Branded<1027, "ClusterId">;
          name: "PressureMeasurement";
          revision: 3;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                extended: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxMeasuredValue: Attribute<null | number, any>;
            maxScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any>;
            minMeasuredValue: Attribute<null | number, any>;
            minScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scale: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scaledTolerance: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    extended: boolean;
                }];
            };
            scaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            tolerance: OptionalAttribute<number, any>;
        };
        features: {
            extended: BitFlag;
        };
        id: Branded<1027, "ClusterId">;
        name: "PressureMeasurement";
        revision: 3;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                extended: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxMeasuredValue: Attribute<null | number, any>;
            maxScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any>;
            minMeasuredValue: Attribute<null | number, any>;
            minScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scale: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scaledTolerance: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    extended: boolean;
                }];
            };
            scaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            tolerance: OptionalAttribute<number, any>;
        };
        features: {
            extended: BitFlag;
        };
        id: Branded<1027, "ClusterId">;
        name: "PressureMeasurement";
        revision: 3;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          maxMeasuredValue: null | number;
          maxScaledValue?: null | number;
          measuredValue: null | number;
          minMeasuredValue: null | number;
          minScaledValue?: null | number;
          scale?: number;
          scaledTolerance?: number;
          scaledValue?: null | number;
          tolerance?: number;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                extended: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxMeasuredValue: Attribute<null | number, any>;
            maxScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any>;
            minMeasuredValue: Attribute<null | number, any>;
            minScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scale: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scaledTolerance: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    extended: boolean;
                }];
            };
            scaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            tolerance: OptionalAttribute<number, any>;
        };
        features: {
            extended: BitFlag;
        };
        id: Branded<1027, "ClusterId">;
        name: "PressureMeasurement";
        revision: 3;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                extended: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxMeasuredValue: Attribute<null | number, any>;
            maxScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any>;
            minMeasuredValue: Attribute<null | number, any>;
            minScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scale: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scaledTolerance: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    extended: boolean;
                }];
            };
            scaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            tolerance: OptionalAttribute<number, any>;
        };
        features: {
            extended: BitFlag;
        };
        id: Branded<1027, "ClusterId">;
        name: "PressureMeasurement";
        revision: 3;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              attributeList: Attribute<AttributeId[], never>;
              clusterRevision: Attribute<number, never>;
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  extended: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              maxMeasuredValue: Attribute<null | number, any>;
              maxScaledValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      extended: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              measuredValue: Attribute<null | number, any>;
              minMeasuredValue: Attribute<null | number, any>;
              minScaledValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      extended: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              scale: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      extended: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              scaledTolerance: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      extended: boolean;
                  }];
              };
              scaledValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      extended: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              tolerance: OptionalAttribute<number, any>;
          };
          features: {
              extended: BitFlag;
          };
          id: Branded<1027, "ClusterId">;
          name: "PressureMeasurement";
          revision: 3;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            clusterRevision: Attribute<number, never>;
            featureMap: Attribute<TypeFromPartialBitSchema<{
                extended: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            maxMeasuredValue: Attribute<null | number, any>;
            maxScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any>;
            minMeasuredValue: Attribute<null | number, any>;
            minScaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scale: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            scaledTolerance: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    extended: boolean;
                }];
            };
            scaledValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    extended: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            tolerance: OptionalAttribute<number, any>;
        };
        features: {
            extended: BitFlag;
        };
        id: Branded<1027, "ClusterId">;
        name: "PressureMeasurement";
        revision: 3;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods