Interface Complete

An identity type.

You can't do:

interface Foo extends typeof Bar {}

But you can do:

interface Foo extends Identity<typeof Bar> {}

Without this type you'd have to do:

interface FooType = typeof Bar;
interface Foo extends FooType {};

We have to do this a lot because we generate complex objects with detailed type information. When exported, TS (as of 5.2) inlines the type of these objects in declarations which makes our declarations massive. To avoid this we create an interface from the type then cast to the interface for export.

interface Complete {
    attributes: Merge<{
        averageMeasuredValue: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                averageMeasurement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        averageMeasuredValueWindow: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                averageMeasurement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        levelValue: Attribute<ConcentrationMeasurement.LevelValue, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                levelIndication: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        maxMeasuredValue: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                numericMeasurement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        measuredValue: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                numericMeasurement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        measurementMedium: FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
        measurementUnit: FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                numericMeasurement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        minMeasuredValue: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                numericMeasurement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        peakMeasuredValue: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                peakMeasurement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        peakMeasuredValueWindow: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                peakMeasurement: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        uncertainty: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                numericMeasurement: boolean;
            }];
        };
    }, GlobalAttributes<{
        averageMeasurement: BitFlag;
        criticalLevel: BitFlag;
        levelIndication: BitFlag;
        mediumLevel: BitFlag;
        numericMeasurement: BitFlag;
        peakMeasurement: BitFlag;
    }>>;
    base: undefined;
    commands: {};
    events: {};
    extensions: undefined;
    features: {
        averageMeasurement: BitFlag;
        criticalLevel: BitFlag;
        levelIndication: BitFlag;
        mediumLevel: BitFlag;
        numericMeasurement: BitFlag;
        peakMeasurement: BitFlag;
    };
    id: Branded<1066, "ClusterId">;
    name: "Pm25ConcentrationMeasurement";
    revision: 3;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            averageMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            averageMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            levelValue: Attribute<ConcentrationMeasurement.LevelValue, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    levelIndication: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measurementMedium: FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
            measurementUnit: FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            uncertainty: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    numericMeasurement: boolean;
                }];
            };
        };
        features: {
            averageMeasurement: BitFlag;
            criticalLevel: BitFlag;
            levelIndication: BitFlag;
            mediumLevel: BitFlag;
            numericMeasurement: BitFlag;
            peakMeasurement: BitFlag;
        };
        id: 1066;
        name: "Pm25ConcentrationMeasurement";
        revision: 3;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            averageMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            averageMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            levelValue: Attribute<ConcentrationMeasurement.LevelValue, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    levelIndication: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measurementMedium: FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
            measurementUnit: FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            uncertainty: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    numericMeasurement: boolean;
                }];
            };
        };
        features: {
            averageMeasurement: BitFlag;
            criticalLevel: BitFlag;
            levelIndication: BitFlag;
            mediumLevel: BitFlag;
            numericMeasurement: BitFlag;
            peakMeasurement: BitFlag;
        };
        id: 1066;
        name: "Pm25ConcentrationMeasurement";
        revision: 3;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            averageMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            averageMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            levelValue: Attribute<ConcentrationMeasurement.LevelValue, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    levelIndication: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measurementMedium: FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
            measurementUnit: FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            uncertainty: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    numericMeasurement: boolean;
                }];
            };
        };
        features: {
            averageMeasurement: BitFlag;
            criticalLevel: BitFlag;
            levelIndication: BitFlag;
            mediumLevel: BitFlag;
            numericMeasurement: BitFlag;
            peakMeasurement: BitFlag;
        };
        id: 1066;
        name: "Pm25ConcentrationMeasurement";
        revision: 3;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            averageMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            averageMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            levelValue: Attribute<ConcentrationMeasurement.LevelValue, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    levelIndication: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measurementMedium: FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
            measurementUnit: FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            uncertainty: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    numericMeasurement: boolean;
                }];
            };
        };
        features: {
            averageMeasurement: BitFlag;
            criticalLevel: BitFlag;
            levelIndication: BitFlag;
            mediumLevel: BitFlag;
            numericMeasurement: BitFlag;
            peakMeasurement: BitFlag;
        };
        id: 1066;
        name: "Pm25ConcentrationMeasurement";
        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<{
    averageMeasuredValue: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            averageMeasurement: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    averageMeasuredValueWindow: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            averageMeasurement: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    levelValue: Attribute<ConcentrationMeasurement.LevelValue, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            levelIndication: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    maxMeasuredValue: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            numericMeasurement: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    measuredValue: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            numericMeasurement: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    measurementMedium: FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
    measurementUnit: FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            numericMeasurement: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    minMeasuredValue: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            numericMeasurement: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    peakMeasuredValue: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            peakMeasurement: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    peakMeasuredValueWindow: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            peakMeasurement: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    uncertainty: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            numericMeasurement: boolean;
        }];
    };
}, GlobalAttributes<{
    averageMeasurement: BitFlag;
    criticalLevel: BitFlag;
    levelIndication: BitFlag;
    mediumLevel: BitFlag;
    numericMeasurement: BitFlag;
    peakMeasurement: BitFlag;
}>>

Type declaration

  • ReadonlyaverageMeasuredValue: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            averageMeasurement: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyaverageMeasuredValueWindow: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            averageMeasurement: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlylevelValue: Attribute<ConcentrationMeasurement.LevelValue, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            levelIndication: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlymaxMeasuredValue: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            numericMeasurement: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlymeasuredValue: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            numericMeasurement: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlymeasurementMedium: FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>

    Indicates the medium in which MeasuredValue is being measured. See MeasurementMediumEnum.

    See

    MatterSpecification.v13.Cluster § 2.10.6.10

  • ReadonlymeasurementUnit: FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            numericMeasurement: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyminMeasuredValue: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            numericMeasurement: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlypeakMeasuredValue: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            peakMeasurement: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlypeakMeasuredValueWindow: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            peakMeasurement: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • Readonlyuncertainty: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            numericMeasurement: boolean;
        }];
    }

base

base: undefined

commands

commands: {}

events

events: {}

extensions

extensions: undefined

features

features: {
    averageMeasurement: BitFlag;
    criticalLevel: BitFlag;
    levelIndication: BitFlag;
    mediumLevel: BitFlag;
    numericMeasurement: BitFlag;
    peakMeasurement: BitFlag;
}

Type declaration

  • ReadonlyaverageMeasurement: BitFlag

    AverageMeasurement

    Cluster supports average numeric measurement of substance

  • ReadonlycriticalLevel: BitFlag

    CriticalLevel

    Cluster supports the Critical Concentration Level

  • ReadonlylevelIndication: BitFlag

    LevelIndication

    Cluster supports basic level indication for substance using the ConcentrationLevel enum

  • ReadonlymediumLevel: BitFlag

    MediumLevel

    Cluster supports the Medium Concentration Level

  • ReadonlynumericMeasurement: BitFlag

    NumericMeasurement

    Cluster supports numeric measurement of substance

  • ReadonlypeakMeasurement: BitFlag

    PeakMeasurement

    Cluster supports peak numeric measurement of substance

id

id: Branded<1066, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            averageMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            averageMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            levelValue: Attribute<ConcentrationMeasurement.LevelValue, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    levelIndication: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measurementMedium: FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
            measurementUnit: FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            uncertainty: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    numericMeasurement: boolean;
                }];
            };
        };
        features: {
            averageMeasurement: BitFlag;
            criticalLevel: BitFlag;
            levelIndication: BitFlag;
            mediumLevel: BitFlag;
            numericMeasurement: BitFlag;
            peakMeasurement: BitFlag;
        };
        id: 1066;
        name: "Pm25ConcentrationMeasurement";
        revision: 3;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              averageMeasuredValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      averageMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              averageMeasuredValueWindow: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      averageMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              levelValue: Attribute<ConcentrationMeasurement.LevelValue, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      levelIndication: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              maxMeasuredValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      numericMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              measuredValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      numericMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              measurementMedium: FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
              measurementUnit: FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      numericMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minMeasuredValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      numericMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              peakMeasuredValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      peakMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              peakMeasuredValueWindow: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      peakMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              uncertainty: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      numericMeasurement: boolean;
                  }];
              };
          };
          features: {
              averageMeasurement: BitFlag;
              criticalLevel: BitFlag;
              levelIndication: BitFlag;
              mediumLevel: BitFlag;
              numericMeasurement: BitFlag;
              peakMeasurement: BitFlag;
          };
          id: 1066;
          name: "Pm25ConcentrationMeasurement";
          revision: 3;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            averageMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            averageMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            levelValue: Attribute<ConcentrationMeasurement.LevelValue, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    levelIndication: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measurementMedium: FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
            measurementUnit: FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            uncertainty: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    numericMeasurement: boolean;
                }];
            };
        };
        features: {
            averageMeasurement: BitFlag;
            criticalLevel: BitFlag;
            levelIndication: BitFlag;
            mediumLevel: BitFlag;
            numericMeasurement: BitFlag;
            peakMeasurement: BitFlag;
        };
        id: 1066;
        name: "Pm25ConcentrationMeasurement";
        revision: 3;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            averageMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            averageMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            levelValue: Attribute<ConcentrationMeasurement.LevelValue, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    levelIndication: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measurementMedium: FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
            measurementUnit: FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            uncertainty: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    numericMeasurement: boolean;
                }];
            };
        };
        features: {
            averageMeasurement: BitFlag;
            criticalLevel: BitFlag;
            levelIndication: BitFlag;
            mediumLevel: BitFlag;
            numericMeasurement: BitFlag;
            peakMeasurement: BitFlag;
        };
        id: 1066;
        name: "Pm25ConcentrationMeasurement";
        revision: 3;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              averageMeasuredValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      averageMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              averageMeasuredValueWindow: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      averageMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              levelValue: Attribute<ConcentrationMeasurement.LevelValue, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      levelIndication: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              maxMeasuredValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      numericMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              measuredValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      numericMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              measurementMedium: FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
              measurementUnit: FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      numericMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minMeasuredValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      numericMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              peakMeasuredValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      peakMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              peakMeasuredValueWindow: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      peakMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              uncertainty: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      numericMeasurement: boolean;
                  }];
              };
          };
          features: {
              averageMeasurement: BitFlag;
              criticalLevel: BitFlag;
              levelIndication: BitFlag;
              mediumLevel: BitFlag;
              numericMeasurement: BitFlag;
              peakMeasurement: BitFlag;
          };
          id: 1066;
          name: "Pm25ConcentrationMeasurement";
          revision: 3;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            averageMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            averageMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            levelValue: Attribute<ConcentrationMeasurement.LevelValue, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    levelIndication: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measurementMedium: FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
            measurementUnit: FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            uncertainty: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    numericMeasurement: boolean;
                }];
            };
        };
        features: {
            averageMeasurement: BitFlag;
            criticalLevel: BitFlag;
            levelIndication: BitFlag;
            mediumLevel: BitFlag;
            numericMeasurement: BitFlag;
            peakMeasurement: BitFlag;
        };
        id: 1066;
        name: "Pm25ConcentrationMeasurement";
        revision: 3;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            averageMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            averageMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            levelValue: Attribute<ConcentrationMeasurement.LevelValue, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    levelIndication: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measurementMedium: FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
            measurementUnit: FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            uncertainty: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    numericMeasurement: boolean;
                }];
            };
        };
        features: {
            averageMeasurement: BitFlag;
            criticalLevel: BitFlag;
            levelIndication: BitFlag;
            mediumLevel: BitFlag;
            numericMeasurement: BitFlag;
            peakMeasurement: BitFlag;
        };
        id: 1066;
        name: "Pm25ConcentrationMeasurement";
        revision: 3;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          averageMeasuredValue?: null | number;
          averageMeasuredValueWindow?: number;
          levelValue?: number;
          maxMeasuredValue?: null | number;
          measuredValue?: null | number;
          measurementMedium: number;
          measurementUnit?: number;
          minMeasuredValue?: null | number;
          peakMeasuredValue?: null | number;
          peakMeasuredValueWindow?: number;
          uncertainty?: number;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            averageMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            averageMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            levelValue: Attribute<ConcentrationMeasurement.LevelValue, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    levelIndication: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measurementMedium: FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
            measurementUnit: FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            uncertainty: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    numericMeasurement: boolean;
                }];
            };
        };
        features: {
            averageMeasurement: BitFlag;
            criticalLevel: BitFlag;
            levelIndication: BitFlag;
            mediumLevel: BitFlag;
            numericMeasurement: BitFlag;
            peakMeasurement: BitFlag;
        };
        id: 1066;
        name: "Pm25ConcentrationMeasurement";
        revision: 3;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            averageMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            averageMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            levelValue: Attribute<ConcentrationMeasurement.LevelValue, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    levelIndication: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measurementMedium: FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
            measurementUnit: FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            uncertainty: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    numericMeasurement: boolean;
                }];
            };
        };
        features: {
            averageMeasurement: BitFlag;
            criticalLevel: BitFlag;
            levelIndication: BitFlag;
            mediumLevel: BitFlag;
            numericMeasurement: BitFlag;
            peakMeasurement: BitFlag;
        };
        id: 1066;
        name: "Pm25ConcentrationMeasurement";
        revision: 3;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              averageMeasuredValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      averageMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              averageMeasuredValueWindow: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      averageMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              levelValue: Attribute<ConcentrationMeasurement.LevelValue, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      levelIndication: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              maxMeasuredValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      numericMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              measuredValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      numericMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              measurementMedium: FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
              measurementUnit: FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      numericMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minMeasuredValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      numericMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              peakMeasuredValue: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      peakMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              peakMeasuredValueWindow: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      peakMeasurement: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              uncertainty: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      numericMeasurement: boolean;
                  }];
              };
          };
          features: {
              averageMeasurement: BitFlag;
              criticalLevel: BitFlag;
              levelIndication: BitFlag;
              mediumLevel: BitFlag;
              numericMeasurement: BitFlag;
              peakMeasurement: BitFlag;
          };
          id: 1066;
          name: "Pm25ConcentrationMeasurement";
          revision: 3;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            averageMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            averageMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    averageMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            levelValue: Attribute<ConcentrationMeasurement.LevelValue, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    levelIndication: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            measurementMedium: FixedAttribute<ConcentrationMeasurement.MeasurementMedium, any>;
            measurementUnit: FixedAttribute<ConcentrationMeasurement.MeasurementUnit, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    numericMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValue: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            peakMeasuredValueWindow: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    peakMeasurement: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            uncertainty: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    numericMeasurement: boolean;
                }];
            };
        };
        features: {
            averageMeasurement: BitFlag;
            criticalLevel: BitFlag;
            levelIndication: BitFlag;
            mediumLevel: BitFlag;
            numericMeasurement: BitFlag;
            peakMeasurement: BitFlag;
        };
        id: 1066;
        name: "Pm25ConcentrationMeasurement";
        revision: 3;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods