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<{
        changeIndication: Attribute<ResourceMonitoring.ChangeIndication, any>;
        condition: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                condition: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        degradationDirection: FixedAttribute<ResourceMonitoring.DegradationDirection, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                condition: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        inPlaceIndicator: OptionalAttribute<boolean, any>;
        lastChangedTime: OptionalWritableAttribute<null | number, any>;
        replacementProductList: FixedAttribute<TypeFromFields<{
            productIdentifierType: FieldType<ResourceMonitoring.ProductIdentifierType>;
            productIdentifierValue: FieldType<string>;
        }>[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                replacementProductList: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    }, GlobalAttributes<{
        condition: BitFlag;
        replacementProductList: BitFlag;
        warning: BitFlag;
    }>>;
    base: undefined;
    commands: {
        resetCondition: OptionalCommand<void, void, any>;
    };
    events: {};
    extensions: undefined;
    features: {
        condition: BitFlag;
        replacementProductList: BitFlag;
        warning: BitFlag;
    };
    id: Branded<113, "ClusterId">;
    name: "HepaFilterMonitoring";
    revision: 1;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            changeIndication: Attribute<ResourceMonitoring.ChangeIndication, any>;
            condition: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            degradationDirection: FixedAttribute<ResourceMonitoring.DegradationDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            inPlaceIndicator: OptionalAttribute<boolean, any>;
            lastChangedTime: OptionalWritableAttribute<null | number, any>;
            replacementProductList: FixedAttribute<TypeFromFields<{
                productIdentifierType: FieldType<ResourceMonitoring.ProductIdentifierType>;
                productIdentifierValue: FieldType<string>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    replacementProductList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            resetCondition: OptionalCommand<void, void, any>;
        };
        features: {
            condition: BitFlag;
            replacementProductList: BitFlag;
            warning: BitFlag;
        };
        id: 113;
        name: "HepaFilterMonitoring";
        revision: 1;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            changeIndication: Attribute<ResourceMonitoring.ChangeIndication, any>;
            condition: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            degradationDirection: FixedAttribute<ResourceMonitoring.DegradationDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            inPlaceIndicator: OptionalAttribute<boolean, any>;
            lastChangedTime: OptionalWritableAttribute<null | number, any>;
            replacementProductList: FixedAttribute<TypeFromFields<{
                productIdentifierType: FieldType<ResourceMonitoring.ProductIdentifierType>;
                productIdentifierValue: FieldType<string>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    replacementProductList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            resetCondition: OptionalCommand<void, void, any>;
        };
        features: {
            condition: BitFlag;
            replacementProductList: BitFlag;
            warning: BitFlag;
        };
        id: 113;
        name: "HepaFilterMonitoring";
        revision: 1;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            changeIndication: Attribute<ResourceMonitoring.ChangeIndication, any>;
            condition: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            degradationDirection: FixedAttribute<ResourceMonitoring.DegradationDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            inPlaceIndicator: OptionalAttribute<boolean, any>;
            lastChangedTime: OptionalWritableAttribute<null | number, any>;
            replacementProductList: FixedAttribute<TypeFromFields<{
                productIdentifierType: FieldType<ResourceMonitoring.ProductIdentifierType>;
                productIdentifierValue: FieldType<string>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    replacementProductList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            resetCondition: OptionalCommand<void, void, any>;
        };
        features: {
            condition: BitFlag;
            replacementProductList: BitFlag;
            warning: BitFlag;
        };
        id: 113;
        name: "HepaFilterMonitoring";
        revision: 1;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            changeIndication: Attribute<ResourceMonitoring.ChangeIndication, any>;
            condition: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            degradationDirection: FixedAttribute<ResourceMonitoring.DegradationDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            inPlaceIndicator: OptionalAttribute<boolean, any>;
            lastChangedTime: OptionalWritableAttribute<null | number, any>;
            replacementProductList: FixedAttribute<TypeFromFields<{
                productIdentifierType: FieldType<ResourceMonitoring.ProductIdentifierType>;
                productIdentifierValue: FieldType<string>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    replacementProductList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            resetCondition: OptionalCommand<void, void, any>;
        };
        features: {
            condition: BitFlag;
            replacementProductList: BitFlag;
            warning: BitFlag;
        };
        id: 113;
        name: "HepaFilterMonitoring";
        revision: 1;
    }>, SelectionT>;
}

Hierarchy (view full)

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    changeIndication: Attribute<ResourceMonitoring.ChangeIndication, any>;
    condition: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            condition: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    degradationDirection: FixedAttribute<ResourceMonitoring.DegradationDirection, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            condition: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    inPlaceIndicator: OptionalAttribute<boolean, any>;
    lastChangedTime: OptionalWritableAttribute<null | number, any>;
    replacementProductList: FixedAttribute<TypeFromFields<{
        productIdentifierType: FieldType<ResourceMonitoring.ProductIdentifierType>;
        productIdentifierValue: FieldType<string>;
    }>[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            replacementProductList: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}, GlobalAttributes<{
    condition: BitFlag;
    replacementProductList: BitFlag;
    warning: BitFlag;
}>>

base

base: undefined

commands

commands: {
    resetCondition: OptionalCommand<void, void, any>;
}

events

events: {}

extensions

extensions: undefined

features

features: {
    condition: BitFlag;
    replacementProductList: BitFlag;
    warning: BitFlag;
}

id

id: Branded<113, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            changeIndication: Attribute<ResourceMonitoring.ChangeIndication, any>;
            condition: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            degradationDirection: FixedAttribute<ResourceMonitoring.DegradationDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            inPlaceIndicator: OptionalAttribute<boolean, any>;
            lastChangedTime: OptionalWritableAttribute<null | number, any>;
            replacementProductList: FixedAttribute<TypeFromFields<{
                productIdentifierType: FieldType<ResourceMonitoring.ProductIdentifierType>;
                productIdentifierValue: FieldType<string>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    replacementProductList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            resetCondition: OptionalCommand<void, void, any>;
        };
        features: {
            condition: BitFlag;
            replacementProductList: BitFlag;
            warning: BitFlag;
        };
        id: 113;
        name: "HepaFilterMonitoring";
        revision: 1;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              changeIndication: Attribute<ResourceMonitoring.ChangeIndication, any>;
              condition: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      condition: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              degradationDirection: FixedAttribute<ResourceMonitoring.DegradationDirection, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      condition: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              inPlaceIndicator: OptionalAttribute<boolean, any>;
              lastChangedTime: OptionalWritableAttribute<null | number, any>;
              replacementProductList: FixedAttribute<TypeFromFields<{
                  productIdentifierType: FieldType<ResourceMonitoring.ProductIdentifierType>;
                  productIdentifierValue: FieldType<string>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      replacementProductList: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              resetCondition: OptionalCommand<void, void, any>;
          };
          features: {
              condition: BitFlag;
              replacementProductList: BitFlag;
              warning: BitFlag;
          };
          id: 113;
          name: "HepaFilterMonitoring";
          revision: 1;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            changeIndication: Attribute<ResourceMonitoring.ChangeIndication, any>;
            condition: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            degradationDirection: FixedAttribute<ResourceMonitoring.DegradationDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            inPlaceIndicator: OptionalAttribute<boolean, any>;
            lastChangedTime: OptionalWritableAttribute<null | number, any>;
            replacementProductList: FixedAttribute<TypeFromFields<{
                productIdentifierType: FieldType<ResourceMonitoring.ProductIdentifierType>;
                productIdentifierValue: FieldType<string>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    replacementProductList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            resetCondition: OptionalCommand<void, void, any>;
        };
        features: {
            condition: BitFlag;
            replacementProductList: BitFlag;
            warning: BitFlag;
        };
        id: 113;
        name: "HepaFilterMonitoring";
        revision: 1;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            changeIndication: Attribute<ResourceMonitoring.ChangeIndication, any>;
            condition: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            degradationDirection: FixedAttribute<ResourceMonitoring.DegradationDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            inPlaceIndicator: OptionalAttribute<boolean, any>;
            lastChangedTime: OptionalWritableAttribute<null | number, any>;
            replacementProductList: FixedAttribute<TypeFromFields<{
                productIdentifierType: FieldType<ResourceMonitoring.ProductIdentifierType>;
                productIdentifierValue: FieldType<string>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    replacementProductList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            resetCondition: OptionalCommand<void, void, any>;
        };
        features: {
            condition: BitFlag;
            replacementProductList: BitFlag;
            warning: BitFlag;
        };
        id: 113;
        name: "HepaFilterMonitoring";
        revision: 1;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              changeIndication: Attribute<ResourceMonitoring.ChangeIndication, any>;
              condition: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      condition: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              degradationDirection: FixedAttribute<ResourceMonitoring.DegradationDirection, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      condition: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              inPlaceIndicator: OptionalAttribute<boolean, any>;
              lastChangedTime: OptionalWritableAttribute<null | number, any>;
              replacementProductList: FixedAttribute<TypeFromFields<{
                  productIdentifierType: FieldType<ResourceMonitoring.ProductIdentifierType>;
                  productIdentifierValue: FieldType<string>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      replacementProductList: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              resetCondition: OptionalCommand<void, void, any>;
          };
          features: {
              condition: BitFlag;
              replacementProductList: BitFlag;
              warning: BitFlag;
          };
          id: 113;
          name: "HepaFilterMonitoring";
          revision: 1;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            changeIndication: Attribute<ResourceMonitoring.ChangeIndication, any>;
            condition: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            degradationDirection: FixedAttribute<ResourceMonitoring.DegradationDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            inPlaceIndicator: OptionalAttribute<boolean, any>;
            lastChangedTime: OptionalWritableAttribute<null | number, any>;
            replacementProductList: FixedAttribute<TypeFromFields<{
                productIdentifierType: FieldType<ResourceMonitoring.ProductIdentifierType>;
                productIdentifierValue: FieldType<string>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    replacementProductList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            resetCondition: OptionalCommand<void, void, any>;
        };
        features: {
            condition: BitFlag;
            replacementProductList: BitFlag;
            warning: BitFlag;
        };
        id: 113;
        name: "HepaFilterMonitoring";
        revision: 1;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            changeIndication: Attribute<ResourceMonitoring.ChangeIndication, any>;
            condition: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            degradationDirection: FixedAttribute<ResourceMonitoring.DegradationDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            inPlaceIndicator: OptionalAttribute<boolean, any>;
            lastChangedTime: OptionalWritableAttribute<null | number, any>;
            replacementProductList: FixedAttribute<TypeFromFields<{
                productIdentifierType: FieldType<ResourceMonitoring.ProductIdentifierType>;
                productIdentifierValue: FieldType<string>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    replacementProductList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            resetCondition: OptionalCommand<void, void, any>;
        };
        features: {
            condition: BitFlag;
            replacementProductList: BitFlag;
            warning: BitFlag;
        };
        id: 113;
        name: "HepaFilterMonitoring";
        revision: 1;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          changeIndication: number;
          condition?: number;
          degradationDirection?: number;
          inPlaceIndicator?: boolean;
          lastChangedTime?: null | number;
          replacementProductList?: {
              productIdentifierType: number;
              productIdentifierValue: string;
          }[];
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            changeIndication: Attribute<ResourceMonitoring.ChangeIndication, any>;
            condition: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            degradationDirection: FixedAttribute<ResourceMonitoring.DegradationDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            inPlaceIndicator: OptionalAttribute<boolean, any>;
            lastChangedTime: OptionalWritableAttribute<null | number, any>;
            replacementProductList: FixedAttribute<TypeFromFields<{
                productIdentifierType: FieldType<ResourceMonitoring.ProductIdentifierType>;
                productIdentifierValue: FieldType<string>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    replacementProductList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            resetCondition: OptionalCommand<void, void, any>;
        };
        features: {
            condition: BitFlag;
            replacementProductList: BitFlag;
            warning: BitFlag;
        };
        id: 113;
        name: "HepaFilterMonitoring";
        revision: 1;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            changeIndication: Attribute<ResourceMonitoring.ChangeIndication, any>;
            condition: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            degradationDirection: FixedAttribute<ResourceMonitoring.DegradationDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            inPlaceIndicator: OptionalAttribute<boolean, any>;
            lastChangedTime: OptionalWritableAttribute<null | number, any>;
            replacementProductList: FixedAttribute<TypeFromFields<{
                productIdentifierType: FieldType<ResourceMonitoring.ProductIdentifierType>;
                productIdentifierValue: FieldType<string>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    replacementProductList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            resetCondition: OptionalCommand<void, void, any>;
        };
        features: {
            condition: BitFlag;
            replacementProductList: BitFlag;
            warning: BitFlag;
        };
        id: 113;
        name: "HepaFilterMonitoring";
        revision: 1;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              changeIndication: Attribute<ResourceMonitoring.ChangeIndication, any>;
              condition: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      condition: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              degradationDirection: FixedAttribute<ResourceMonitoring.DegradationDirection, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      condition: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              inPlaceIndicator: OptionalAttribute<boolean, any>;
              lastChangedTime: OptionalWritableAttribute<null | number, any>;
              replacementProductList: FixedAttribute<TypeFromFields<{
                  productIdentifierType: FieldType<ResourceMonitoring.ProductIdentifierType>;
                  productIdentifierValue: FieldType<string>;
              }>[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      replacementProductList: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              resetCondition: OptionalCommand<void, void, any>;
          };
          features: {
              condition: BitFlag;
              replacementProductList: BitFlag;
              warning: BitFlag;
          };
          id: 113;
          name: "HepaFilterMonitoring";
          revision: 1;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            changeIndication: Attribute<ResourceMonitoring.ChangeIndication, any>;
            condition: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            degradationDirection: FixedAttribute<ResourceMonitoring.DegradationDirection, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    condition: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            inPlaceIndicator: OptionalAttribute<boolean, any>;
            lastChangedTime: OptionalWritableAttribute<null | number, any>;
            replacementProductList: FixedAttribute<TypeFromFields<{
                productIdentifierType: FieldType<ResourceMonitoring.ProductIdentifierType>;
                productIdentifierValue: FieldType<string>;
            }>[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    replacementProductList: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            resetCondition: OptionalCommand<void, void, any>;
        };
        features: {
            condition: BitFlag;
            replacementProductList: BitFlag;
            warning: BitFlag;
        };
        id: 113;
        name: "HepaFilterMonitoring";
        revision: 1;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods