Interface Cluster

This cluster is used to configure a valve.

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

See

MatterSpecification.v13.Cluster § 4.6

interface Cluster {
    attributes: Merge<{
        currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
        defaultOpenDuration: WritableAttribute<null | number, any>;
        openDuration: Attribute<null | number, any>;
        remainingDuration: Attribute<null | number, any>;
        targetState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
        valveFault: OptionalAttribute<TypeFromPartialBitSchema<{
            blocked: BitFlag;
            currentExceeded: BitFlag;
            generalFault: BitFlag;
            leaking: BitFlag;
            notConnected: BitFlag;
            shortCircuit: BitFlag;
        }>, any>;
    }, GlobalAttributes<{
        level: BitFlag;
        timeSync: BitFlag;
    }>>;
    base: undefined;
    commands: {
        close: Command<void, void, any>;
        open: Command<TypeFromFields<{
            openDuration: OptionalFieldType<null | number>;
            targetLevel: OptionalFieldType<number>;
        }>, void, any>;
    };
    events: {
        valveFault: OptionalEvent<TypeFromFields<{
            valveFault: FieldType<TypeFromPartialBitSchema<{
                blocked: BitFlag;
                currentExceeded: BitFlag;
                generalFault: BitFlag;
                leaking: BitFlag;
                notConnected: BitFlag;
                shortCircuit: BitFlag;
            }>>;
        }>, any>;
        valveStateChanged: OptionalEvent<TypeFromFields<{
            valveLevel: OptionalFieldType<number>;
            valveState: FieldType<ValveConfigurationAndControl.ValveState>;
        }>, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                autoCloseTime: Attribute<null | number | bigint, any>;
            };
        };
        flags: {
            timeSync: true;
        };
    }, {
        component: {
            attributes: {
                currentLevel: Attribute<null | number, any>;
                defaultOpenLevel: OptionalWritableAttribute<number, any>;
                levelStep: OptionalFixedAttribute<number, any>;
                targetLevel: Attribute<null | number, any>;
            };
        };
        flags: {
            level: true;
        };
    }];
    features: {
        level: BitFlag;
        timeSync: BitFlag;
    };
    id: Branded<129, "ClusterId">;
    name: "ValveConfigurationAndControl";
    revision: 1;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            defaultOpenDuration: WritableAttribute<null | number, any>;
            openDuration: Attribute<null | number, any>;
            remainingDuration: Attribute<null | number, any>;
            targetState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            valveFault: OptionalAttribute<TypeFromPartialBitSchema<{
                blocked: BitFlag;
                currentExceeded: BitFlag;
                generalFault: BitFlag;
                leaking: BitFlag;
                notConnected: BitFlag;
                shortCircuit: BitFlag;
            }>, any>;
        };
        commands: {
            close: Command<void, void, any>;
            open: Command<TypeFromFields<{
                openDuration: OptionalFieldType<null | number>;
                targetLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        events: {
            valveFault: OptionalEvent<TypeFromFields<{
                valveFault: FieldType<TypeFromPartialBitSchema<{
                    blocked: BitFlag;
                    currentExceeded: BitFlag;
                    generalFault: BitFlag;
                    leaking: BitFlag;
                    notConnected: BitFlag;
                    shortCircuit: BitFlag;
                }>>;
            }>, any>;
            valveStateChanged: OptionalEvent<TypeFromFields<{
                valveLevel: OptionalFieldType<number>;
                valveState: FieldType<ValveConfigurationAndControl.ValveState>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    autoCloseTime: Attribute<null | number | bigint, any>;
                };
            };
            flags: {
                timeSync: true;
            };
        }, {
            component: {
                attributes: {
                    currentLevel: Attribute<null | number, any>;
                    defaultOpenLevel: OptionalWritableAttribute<number, any>;
                    levelStep: OptionalFixedAttribute<number, any>;
                    targetLevel: Attribute<null | number, any>;
                };
            };
            flags: {
                level: true;
            };
        }];
        features: {
            level: BitFlag;
            timeSync: BitFlag;
        };
        id: 129;
        name: "ValveConfigurationAndControl";
        revision: 1;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            defaultOpenDuration: WritableAttribute<null | number, any>;
            openDuration: Attribute<null | number, any>;
            remainingDuration: Attribute<null | number, any>;
            targetState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            valveFault: OptionalAttribute<TypeFromPartialBitSchema<{
                blocked: BitFlag;
                currentExceeded: BitFlag;
                generalFault: BitFlag;
                leaking: BitFlag;
                notConnected: BitFlag;
                shortCircuit: BitFlag;
            }>, any>;
        };
        commands: {
            close: Command<void, void, any>;
            open: Command<TypeFromFields<{
                openDuration: OptionalFieldType<null | number>;
                targetLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        events: {
            valveFault: OptionalEvent<TypeFromFields<{
                valveFault: FieldType<TypeFromPartialBitSchema<{
                    blocked: BitFlag;
                    currentExceeded: BitFlag;
                    generalFault: BitFlag;
                    leaking: BitFlag;
                    notConnected: BitFlag;
                    shortCircuit: BitFlag;
                }>>;
            }>, any>;
            valveStateChanged: OptionalEvent<TypeFromFields<{
                valveLevel: OptionalFieldType<number>;
                valveState: FieldType<ValveConfigurationAndControl.ValveState>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    autoCloseTime: Attribute<null | number | bigint, any>;
                };
            };
            flags: {
                timeSync: true;
            };
        }, {
            component: {
                attributes: {
                    currentLevel: Attribute<null | number, any>;
                    defaultOpenLevel: OptionalWritableAttribute<number, any>;
                    levelStep: OptionalFixedAttribute<number, any>;
                    targetLevel: Attribute<null | number, any>;
                };
            };
            flags: {
                level: true;
            };
        }];
        features: {
            level: BitFlag;
            timeSync: BitFlag;
        };
        id: 129;
        name: "ValveConfigurationAndControl";
        revision: 1;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            defaultOpenDuration: WritableAttribute<null | number, any>;
            openDuration: Attribute<null | number, any>;
            remainingDuration: Attribute<null | number, any>;
            targetState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            valveFault: OptionalAttribute<TypeFromPartialBitSchema<{
                blocked: BitFlag;
                currentExceeded: BitFlag;
                generalFault: BitFlag;
                leaking: BitFlag;
                notConnected: BitFlag;
                shortCircuit: BitFlag;
            }>, any>;
        };
        commands: {
            close: Command<void, void, any>;
            open: Command<TypeFromFields<{
                openDuration: OptionalFieldType<null | number>;
                targetLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        events: {
            valveFault: OptionalEvent<TypeFromFields<{
                valveFault: FieldType<TypeFromPartialBitSchema<{
                    blocked: BitFlag;
                    currentExceeded: BitFlag;
                    generalFault: BitFlag;
                    leaking: BitFlag;
                    notConnected: BitFlag;
                    shortCircuit: BitFlag;
                }>>;
            }>, any>;
            valveStateChanged: OptionalEvent<TypeFromFields<{
                valveLevel: OptionalFieldType<number>;
                valveState: FieldType<ValveConfigurationAndControl.ValveState>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    autoCloseTime: Attribute<null | number | bigint, any>;
                };
            };
            flags: {
                timeSync: true;
            };
        }, {
            component: {
                attributes: {
                    currentLevel: Attribute<null | number, any>;
                    defaultOpenLevel: OptionalWritableAttribute<number, any>;
                    levelStep: OptionalFixedAttribute<number, any>;
                    targetLevel: Attribute<null | number, any>;
                };
            };
            flags: {
                level: true;
            };
        }];
        features: {
            level: BitFlag;
            timeSync: BitFlag;
        };
        id: 129;
        name: "ValveConfigurationAndControl";
        revision: 1;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            defaultOpenDuration: WritableAttribute<null | number, any>;
            openDuration: Attribute<null | number, any>;
            remainingDuration: Attribute<null | number, any>;
            targetState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            valveFault: OptionalAttribute<TypeFromPartialBitSchema<{
                blocked: BitFlag;
                currentExceeded: BitFlag;
                generalFault: BitFlag;
                leaking: BitFlag;
                notConnected: BitFlag;
                shortCircuit: BitFlag;
            }>, any>;
        };
        commands: {
            close: Command<void, void, any>;
            open: Command<TypeFromFields<{
                openDuration: OptionalFieldType<null | number>;
                targetLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        events: {
            valveFault: OptionalEvent<TypeFromFields<{
                valveFault: FieldType<TypeFromPartialBitSchema<{
                    blocked: BitFlag;
                    currentExceeded: BitFlag;
                    generalFault: BitFlag;
                    leaking: BitFlag;
                    notConnected: BitFlag;
                    shortCircuit: BitFlag;
                }>>;
            }>, any>;
            valveStateChanged: OptionalEvent<TypeFromFields<{
                valveLevel: OptionalFieldType<number>;
                valveState: FieldType<ValveConfigurationAndControl.ValveState>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    autoCloseTime: Attribute<null | number | bigint, any>;
                };
            };
            flags: {
                timeSync: true;
            };
        }, {
            component: {
                attributes: {
                    currentLevel: Attribute<null | number, any>;
                    defaultOpenLevel: OptionalWritableAttribute<number, any>;
                    levelStep: OptionalFixedAttribute<number, any>;
                    targetLevel: Attribute<null | number, any>;
                };
            };
            flags: {
                level: true;
            };
        }];
        features: {
            level: BitFlag;
            timeSync: BitFlag;
        };
        id: 129;
        name: "ValveConfigurationAndControl";
        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<{
    currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
    defaultOpenDuration: WritableAttribute<null | number, any>;
    openDuration: Attribute<null | number, any>;
    remainingDuration: Attribute<null | number, any>;
    targetState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
    valveFault: OptionalAttribute<TypeFromPartialBitSchema<{
        blocked: BitFlag;
        currentExceeded: BitFlag;
        generalFault: BitFlag;
        leaking: BitFlag;
        notConnected: BitFlag;
        shortCircuit: BitFlag;
    }>, any>;
}, GlobalAttributes<{
    level: BitFlag;
    timeSync: BitFlag;
}>>

Type declaration

  • ReadonlycurrentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>

    Indicates the current state of the valve.

    A value of null shall indicate that the current state is not known.

    See

    MatterSpecification.v13.Cluster § 4.6.7.5

  • ReadonlydefaultOpenDuration: WritableAttribute<null | number, any>

    Indicates the default duration, in seconds, for which the valve will remain open, if the OpenDuration field is not present in the Open command.

    A value of null shall indicate the duration is not set, meaning that the valve will remain open until closed by the user or some other automation.

    See

    MatterSpecification.v13.Cluster § 4.6.7.2

  • ReadonlyopenDuration: Attribute<null | number, any>

    Indicates the total duration, in seconds, for which the valve will remain open for this current opening.

    A value of null shall indicate the duration is not set, meaning that the valve will remain open until closed by the user or some other automation.

    See

    MatterSpecification.v13.Cluster § 4.6.7.1

  • ReadonlyremainingDuration: Attribute<null | number, any>

    Indicates the remaining duration, in seconds, until the valve closes. Null:

    • When OpenDuration is null, or

    • When the valve is closed.

    The value of this attribute shall only be reported in the following cases:

    • When it changes from null to any other value and vice versa, or

    • When it changes to 0, or

    • When it increases, or

    • When the closing time changes.

    Meaning that clients SHOULD NOT rely on the reporting of this attribute in order to keep track of the remaining duration, due to this attribute not being reported during regular countdown.

    When reading this attribute it shall return the remaining duration, in seconds, until the valve closes.

    When the value of this attribute counts down to 0, the valve shall automatically transition to its closed position. The behavior of transitioning to the closed position shall match the behavior described in the Close command.

    See

    MatterSpecification.v13.Cluster § 4.6.7.4

  • ReadonlytargetState: Attribute<null | ValveConfigurationAndControl.ValveState, any>

    Indicates the target state, while changing the state, of the valve.

    A value of null shall indicate that no target position is set, since the change in state is either done or failed.

    See

    MatterSpecification.v13.Cluster § 4.6.7.6

  • ReadonlyvalveFault: OptionalAttribute<TypeFromPartialBitSchema<{
        blocked: BitFlag;
        currentExceeded: BitFlag;
        generalFault: BitFlag;
        leaking: BitFlag;
        notConnected: BitFlag;
        shortCircuit: BitFlag;
    }>, any>

    Indicates any faults registered by the valve.

    See

    MatterSpecification.v13.Cluster § 4.6.7.10

base

base: undefined

commands

commands: {
    close: Command<void, void, any>;
    open: Command<TypeFromFields<{
        openDuration: OptionalFieldType<null | number>;
        targetLevel: OptionalFieldType<number>;
    }>, void, any>;
}

Type declaration

  • Readonlyclose: Command<void, void, any>

    This command is used to set the valve to its closed position.

    See

    MatterSpecification.v13.Cluster § 4.6.8.2

  • Readonlyopen: Command<TypeFromFields<{
        openDuration: OptionalFieldType<null | number>;
        targetLevel: OptionalFieldType<number>;
    }>, void, any>

    This command is used to set the valve to its open position.

    See

    MatterSpecification.v13.Cluster § 4.6.8.1

events

events: {
    valveFault: OptionalEvent<TypeFromFields<{
        valveFault: FieldType<TypeFromPartialBitSchema<{
            blocked: BitFlag;
            currentExceeded: BitFlag;
            generalFault: BitFlag;
            leaking: BitFlag;
            notConnected: BitFlag;
            shortCircuit: BitFlag;
        }>>;
    }>, any>;
    valveStateChanged: OptionalEvent<TypeFromFields<{
        valveLevel: OptionalFieldType<number>;
        valveState: FieldType<ValveConfigurationAndControl.ValveState>;
    }>, any>;
}

Type declaration

extensions

extensions: readonly [{
    component: {
        attributes: {
            autoCloseTime: Attribute<null | number | bigint, any>;
        };
    };
    flags: {
        timeSync: true;
    };
}, {
    component: {
        attributes: {
            currentLevel: Attribute<null | number, any>;
            defaultOpenLevel: OptionalWritableAttribute<number, any>;
            levelStep: OptionalFixedAttribute<number, any>;
            targetLevel: Attribute<null | number, any>;
        };
    };
    flags: {
        level: true;
    };
}]

features

features: {
    level: BitFlag;
    timeSync: BitFlag;
}

Type declaration

  • Readonlylevel: BitFlag

    Level

    This feature shall indicate that the valve is capable of being adjusted to a specific position, as a percentage, of its full range of motion.

    See

    MatterSpecification.v13.Cluster § 4.6.4.2

  • ReadonlytimeSync: BitFlag

    TimeSync

    This feature shall indicate that the valve uses Time Synchronization and UTC time to indicate duration and auto close time.

    This feature shall NOT be supported unless the device supports the Time Synchronization cluster.

    See

    MatterSpecification.v13.Cluster § 4.6.4.1

id

id: Branded<129, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            defaultOpenDuration: WritableAttribute<null | number, any>;
            openDuration: Attribute<null | number, any>;
            remainingDuration: Attribute<null | number, any>;
            targetState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            valveFault: OptionalAttribute<TypeFromPartialBitSchema<{
                blocked: BitFlag;
                currentExceeded: BitFlag;
                generalFault: BitFlag;
                leaking: BitFlag;
                notConnected: BitFlag;
                shortCircuit: BitFlag;
            }>, any>;
        };
        commands: {
            close: Command<void, void, any>;
            open: Command<TypeFromFields<{
                openDuration: OptionalFieldType<null | number>;
                targetLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        events: {
            valveFault: OptionalEvent<TypeFromFields<{
                valveFault: FieldType<TypeFromPartialBitSchema<{
                    blocked: BitFlag;
                    currentExceeded: BitFlag;
                    generalFault: BitFlag;
                    leaking: BitFlag;
                    notConnected: BitFlag;
                    shortCircuit: BitFlag;
                }>>;
            }>, any>;
            valveStateChanged: OptionalEvent<TypeFromFields<{
                valveLevel: OptionalFieldType<number>;
                valveState: FieldType<ValveConfigurationAndControl.ValveState>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    autoCloseTime: Attribute<null | number | bigint, any>;
                };
            };
            flags: {
                timeSync: true;
            };
        }, {
            component: {
                attributes: {
                    currentLevel: Attribute<null | number, any>;
                    defaultOpenLevel: OptionalWritableAttribute<number, any>;
                    levelStep: OptionalFixedAttribute<number, any>;
                    targetLevel: Attribute<null | number, any>;
                };
            };
            flags: {
                level: true;
            };
        }];
        features: {
            level: BitFlag;
            timeSync: BitFlag;
        };
        id: 129;
        name: "ValveConfigurationAndControl";
        revision: 1;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
              defaultOpenDuration: WritableAttribute<null | number, any>;
              openDuration: Attribute<null | number, any>;
              remainingDuration: Attribute<null | number, any>;
              targetState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
              valveFault: OptionalAttribute<TypeFromPartialBitSchema<{
                  blocked: BitFlag;
                  currentExceeded: BitFlag;
                  generalFault: BitFlag;
                  leaking: BitFlag;
                  notConnected: BitFlag;
                  shortCircuit: BitFlag;
              }>, any>;
          };
          commands: {
              close: Command<void, void, any>;
              open: Command<TypeFromFields<{
                  openDuration: OptionalFieldType<null | number>;
                  targetLevel: OptionalFieldType<number>;
              }>, void, any>;
          };
          events: {
              valveFault: OptionalEvent<TypeFromFields<{
                  valveFault: FieldType<TypeFromPartialBitSchema<{
                      blocked: BitFlag;
                      currentExceeded: BitFlag;
                      generalFault: BitFlag;
                      leaking: BitFlag;
                      notConnected: BitFlag;
                      shortCircuit: BitFlag;
                  }>>;
              }>, any>;
              valveStateChanged: OptionalEvent<TypeFromFields<{
                  valveLevel: OptionalFieldType<number>;
                  valveState: FieldType<ValveConfigurationAndControl.ValveState>;
              }>, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      autoCloseTime: Attribute<null | number | bigint, any>;
                  };
              };
              flags: {
                  timeSync: true;
              };
          }, {
              component: {
                  attributes: {
                      currentLevel: Attribute<null | number, any>;
                      defaultOpenLevel: OptionalWritableAttribute<number, any>;
                      levelStep: OptionalFixedAttribute<number, any>;
                      targetLevel: Attribute<null | number, any>;
                  };
              };
              flags: {
                  level: true;
              };
          }];
          features: {
              level: BitFlag;
              timeSync: BitFlag;
          };
          id: 129;
          name: "ValveConfigurationAndControl";
          revision: 1;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            defaultOpenDuration: WritableAttribute<null | number, any>;
            openDuration: Attribute<null | number, any>;
            remainingDuration: Attribute<null | number, any>;
            targetState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            valveFault: OptionalAttribute<TypeFromPartialBitSchema<{
                blocked: BitFlag;
                currentExceeded: BitFlag;
                generalFault: BitFlag;
                leaking: BitFlag;
                notConnected: BitFlag;
                shortCircuit: BitFlag;
            }>, any>;
        };
        commands: {
            close: Command<void, void, any>;
            open: Command<TypeFromFields<{
                openDuration: OptionalFieldType<null | number>;
                targetLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        events: {
            valveFault: OptionalEvent<TypeFromFields<{
                valveFault: FieldType<TypeFromPartialBitSchema<{
                    blocked: BitFlag;
                    currentExceeded: BitFlag;
                    generalFault: BitFlag;
                    leaking: BitFlag;
                    notConnected: BitFlag;
                    shortCircuit: BitFlag;
                }>>;
            }>, any>;
            valveStateChanged: OptionalEvent<TypeFromFields<{
                valveLevel: OptionalFieldType<number>;
                valveState: FieldType<ValveConfigurationAndControl.ValveState>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    autoCloseTime: Attribute<null | number | bigint, any>;
                };
            };
            flags: {
                timeSync: true;
            };
        }, {
            component: {
                attributes: {
                    currentLevel: Attribute<null | number, any>;
                    defaultOpenLevel: OptionalWritableAttribute<number, any>;
                    levelStep: OptionalFixedAttribute<number, any>;
                    targetLevel: Attribute<null | number, any>;
                };
            };
            flags: {
                level: true;
            };
        }];
        features: {
            level: BitFlag;
            timeSync: BitFlag;
        };
        id: 129;
        name: "ValveConfigurationAndControl";
        revision: 1;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            defaultOpenDuration: WritableAttribute<null | number, any>;
            openDuration: Attribute<null | number, any>;
            remainingDuration: Attribute<null | number, any>;
            targetState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            valveFault: OptionalAttribute<TypeFromPartialBitSchema<{
                blocked: BitFlag;
                currentExceeded: BitFlag;
                generalFault: BitFlag;
                leaking: BitFlag;
                notConnected: BitFlag;
                shortCircuit: BitFlag;
            }>, any>;
        };
        commands: {
            close: Command<void, void, any>;
            open: Command<TypeFromFields<{
                openDuration: OptionalFieldType<null | number>;
                targetLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        events: {
            valveFault: OptionalEvent<TypeFromFields<{
                valveFault: FieldType<TypeFromPartialBitSchema<{
                    blocked: BitFlag;
                    currentExceeded: BitFlag;
                    generalFault: BitFlag;
                    leaking: BitFlag;
                    notConnected: BitFlag;
                    shortCircuit: BitFlag;
                }>>;
            }>, any>;
            valveStateChanged: OptionalEvent<TypeFromFields<{
                valveLevel: OptionalFieldType<number>;
                valveState: FieldType<ValveConfigurationAndControl.ValveState>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    autoCloseTime: Attribute<null | number | bigint, any>;
                };
            };
            flags: {
                timeSync: true;
            };
        }, {
            component: {
                attributes: {
                    currentLevel: Attribute<null | number, any>;
                    defaultOpenLevel: OptionalWritableAttribute<number, any>;
                    levelStep: OptionalFixedAttribute<number, any>;
                    targetLevel: Attribute<null | number, any>;
                };
            };
            flags: {
                level: true;
            };
        }];
        features: {
            level: BitFlag;
            timeSync: BitFlag;
        };
        id: 129;
        name: "ValveConfigurationAndControl";
        revision: 1;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
              defaultOpenDuration: WritableAttribute<null | number, any>;
              openDuration: Attribute<null | number, any>;
              remainingDuration: Attribute<null | number, any>;
              targetState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
              valveFault: OptionalAttribute<TypeFromPartialBitSchema<{
                  blocked: BitFlag;
                  currentExceeded: BitFlag;
                  generalFault: BitFlag;
                  leaking: BitFlag;
                  notConnected: BitFlag;
                  shortCircuit: BitFlag;
              }>, any>;
          };
          commands: {
              close: Command<void, void, any>;
              open: Command<TypeFromFields<{
                  openDuration: OptionalFieldType<null | number>;
                  targetLevel: OptionalFieldType<number>;
              }>, void, any>;
          };
          events: {
              valveFault: OptionalEvent<TypeFromFields<{
                  valveFault: FieldType<TypeFromPartialBitSchema<{
                      blocked: BitFlag;
                      currentExceeded: BitFlag;
                      generalFault: BitFlag;
                      leaking: BitFlag;
                      notConnected: BitFlag;
                      shortCircuit: BitFlag;
                  }>>;
              }>, any>;
              valveStateChanged: OptionalEvent<TypeFromFields<{
                  valveLevel: OptionalFieldType<number>;
                  valveState: FieldType<ValveConfigurationAndControl.ValveState>;
              }>, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      autoCloseTime: Attribute<null | number | bigint, any>;
                  };
              };
              flags: {
                  timeSync: true;
              };
          }, {
              component: {
                  attributes: {
                      currentLevel: Attribute<null | number, any>;
                      defaultOpenLevel: OptionalWritableAttribute<number, any>;
                      levelStep: OptionalFixedAttribute<number, any>;
                      targetLevel: Attribute<null | number, any>;
                  };
              };
              flags: {
                  level: true;
              };
          }];
          features: {
              level: BitFlag;
              timeSync: BitFlag;
          };
          id: 129;
          name: "ValveConfigurationAndControl";
          revision: 1;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            defaultOpenDuration: WritableAttribute<null | number, any>;
            openDuration: Attribute<null | number, any>;
            remainingDuration: Attribute<null | number, any>;
            targetState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            valveFault: OptionalAttribute<TypeFromPartialBitSchema<{
                blocked: BitFlag;
                currentExceeded: BitFlag;
                generalFault: BitFlag;
                leaking: BitFlag;
                notConnected: BitFlag;
                shortCircuit: BitFlag;
            }>, any>;
        };
        commands: {
            close: Command<void, void, any>;
            open: Command<TypeFromFields<{
                openDuration: OptionalFieldType<null | number>;
                targetLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        events: {
            valveFault: OptionalEvent<TypeFromFields<{
                valveFault: FieldType<TypeFromPartialBitSchema<{
                    blocked: BitFlag;
                    currentExceeded: BitFlag;
                    generalFault: BitFlag;
                    leaking: BitFlag;
                    notConnected: BitFlag;
                    shortCircuit: BitFlag;
                }>>;
            }>, any>;
            valveStateChanged: OptionalEvent<TypeFromFields<{
                valveLevel: OptionalFieldType<number>;
                valveState: FieldType<ValveConfigurationAndControl.ValveState>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    autoCloseTime: Attribute<null | number | bigint, any>;
                };
            };
            flags: {
                timeSync: true;
            };
        }, {
            component: {
                attributes: {
                    currentLevel: Attribute<null | number, any>;
                    defaultOpenLevel: OptionalWritableAttribute<number, any>;
                    levelStep: OptionalFixedAttribute<number, any>;
                    targetLevel: Attribute<null | number, any>;
                };
            };
            flags: {
                level: true;
            };
        }];
        features: {
            level: BitFlag;
            timeSync: BitFlag;
        };
        id: 129;
        name: "ValveConfigurationAndControl";
        revision: 1;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            defaultOpenDuration: WritableAttribute<null | number, any>;
            openDuration: Attribute<null | number, any>;
            remainingDuration: Attribute<null | number, any>;
            targetState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            valveFault: OptionalAttribute<TypeFromPartialBitSchema<{
                blocked: BitFlag;
                currentExceeded: BitFlag;
                generalFault: BitFlag;
                leaking: BitFlag;
                notConnected: BitFlag;
                shortCircuit: BitFlag;
            }>, any>;
        };
        commands: {
            close: Command<void, void, any>;
            open: Command<TypeFromFields<{
                openDuration: OptionalFieldType<null | number>;
                targetLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        events: {
            valveFault: OptionalEvent<TypeFromFields<{
                valveFault: FieldType<TypeFromPartialBitSchema<{
                    blocked: BitFlag;
                    currentExceeded: BitFlag;
                    generalFault: BitFlag;
                    leaking: BitFlag;
                    notConnected: BitFlag;
                    shortCircuit: BitFlag;
                }>>;
            }>, any>;
            valveStateChanged: OptionalEvent<TypeFromFields<{
                valveLevel: OptionalFieldType<number>;
                valveState: FieldType<ValveConfigurationAndControl.ValveState>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    autoCloseTime: Attribute<null | number | bigint, any>;
                };
            };
            flags: {
                timeSync: true;
            };
        }, {
            component: {
                attributes: {
                    currentLevel: Attribute<null | number, any>;
                    defaultOpenLevel: OptionalWritableAttribute<number, any>;
                    levelStep: OptionalFixedAttribute<number, any>;
                    targetLevel: Attribute<null | number, any>;
                };
            };
            flags: {
                level: true;
            };
        }];
        features: {
            level: BitFlag;
            timeSync: BitFlag;
        };
        id: 129;
        name: "ValveConfigurationAndControl";
        revision: 1;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          currentState: null | number;
          defaultOpenDuration: null | number;
          openDuration: null | number;
          remainingDuration: null | number;
          targetState: null | number;
          valveFault?: {
              blocked?: boolean;
              currentExceeded?: boolean;
              generalFault?: boolean;
              leaking?: boolean;
              notConnected?: boolean;
              shortCircuit?: boolean;
          };
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            defaultOpenDuration: WritableAttribute<null | number, any>;
            openDuration: Attribute<null | number, any>;
            remainingDuration: Attribute<null | number, any>;
            targetState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            valveFault: OptionalAttribute<TypeFromPartialBitSchema<{
                blocked: BitFlag;
                currentExceeded: BitFlag;
                generalFault: BitFlag;
                leaking: BitFlag;
                notConnected: BitFlag;
                shortCircuit: BitFlag;
            }>, any>;
        };
        commands: {
            close: Command<void, void, any>;
            open: Command<TypeFromFields<{
                openDuration: OptionalFieldType<null | number>;
                targetLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        events: {
            valveFault: OptionalEvent<TypeFromFields<{
                valveFault: FieldType<TypeFromPartialBitSchema<{
                    blocked: BitFlag;
                    currentExceeded: BitFlag;
                    generalFault: BitFlag;
                    leaking: BitFlag;
                    notConnected: BitFlag;
                    shortCircuit: BitFlag;
                }>>;
            }>, any>;
            valveStateChanged: OptionalEvent<TypeFromFields<{
                valveLevel: OptionalFieldType<number>;
                valveState: FieldType<ValveConfigurationAndControl.ValveState>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    autoCloseTime: Attribute<null | number | bigint, any>;
                };
            };
            flags: {
                timeSync: true;
            };
        }, {
            component: {
                attributes: {
                    currentLevel: Attribute<null | number, any>;
                    defaultOpenLevel: OptionalWritableAttribute<number, any>;
                    levelStep: OptionalFixedAttribute<number, any>;
                    targetLevel: Attribute<null | number, any>;
                };
            };
            flags: {
                level: true;
            };
        }];
        features: {
            level: BitFlag;
            timeSync: BitFlag;
        };
        id: 129;
        name: "ValveConfigurationAndControl";
        revision: 1;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            defaultOpenDuration: WritableAttribute<null | number, any>;
            openDuration: Attribute<null | number, any>;
            remainingDuration: Attribute<null | number, any>;
            targetState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            valveFault: OptionalAttribute<TypeFromPartialBitSchema<{
                blocked: BitFlag;
                currentExceeded: BitFlag;
                generalFault: BitFlag;
                leaking: BitFlag;
                notConnected: BitFlag;
                shortCircuit: BitFlag;
            }>, any>;
        };
        commands: {
            close: Command<void, void, any>;
            open: Command<TypeFromFields<{
                openDuration: OptionalFieldType<null | number>;
                targetLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        events: {
            valveFault: OptionalEvent<TypeFromFields<{
                valveFault: FieldType<TypeFromPartialBitSchema<{
                    blocked: BitFlag;
                    currentExceeded: BitFlag;
                    generalFault: BitFlag;
                    leaking: BitFlag;
                    notConnected: BitFlag;
                    shortCircuit: BitFlag;
                }>>;
            }>, any>;
            valveStateChanged: OptionalEvent<TypeFromFields<{
                valveLevel: OptionalFieldType<number>;
                valveState: FieldType<ValveConfigurationAndControl.ValveState>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    autoCloseTime: Attribute<null | number | bigint, any>;
                };
            };
            flags: {
                timeSync: true;
            };
        }, {
            component: {
                attributes: {
                    currentLevel: Attribute<null | number, any>;
                    defaultOpenLevel: OptionalWritableAttribute<number, any>;
                    levelStep: OptionalFixedAttribute<number, any>;
                    targetLevel: Attribute<null | number, any>;
                };
            };
            flags: {
                level: true;
            };
        }];
        features: {
            level: BitFlag;
            timeSync: BitFlag;
        };
        id: 129;
        name: "ValveConfigurationAndControl";
        revision: 1;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
              defaultOpenDuration: WritableAttribute<null | number, any>;
              openDuration: Attribute<null | number, any>;
              remainingDuration: Attribute<null | number, any>;
              targetState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
              valveFault: OptionalAttribute<TypeFromPartialBitSchema<{
                  blocked: BitFlag;
                  currentExceeded: BitFlag;
                  generalFault: BitFlag;
                  leaking: BitFlag;
                  notConnected: BitFlag;
                  shortCircuit: BitFlag;
              }>, any>;
          };
          commands: {
              close: Command<void, void, any>;
              open: Command<TypeFromFields<{
                  openDuration: OptionalFieldType<null | number>;
                  targetLevel: OptionalFieldType<number>;
              }>, void, any>;
          };
          events: {
              valveFault: OptionalEvent<TypeFromFields<{
                  valveFault: FieldType<TypeFromPartialBitSchema<{
                      blocked: BitFlag;
                      currentExceeded: BitFlag;
                      generalFault: BitFlag;
                      leaking: BitFlag;
                      notConnected: BitFlag;
                      shortCircuit: BitFlag;
                  }>>;
              }>, any>;
              valveStateChanged: OptionalEvent<TypeFromFields<{
                  valveLevel: OptionalFieldType<number>;
                  valveState: FieldType<ValveConfigurationAndControl.ValveState>;
              }>, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      autoCloseTime: Attribute<null | number | bigint, any>;
                  };
              };
              flags: {
                  timeSync: true;
              };
          }, {
              component: {
                  attributes: {
                      currentLevel: Attribute<null | number, any>;
                      defaultOpenLevel: OptionalWritableAttribute<number, any>;
                      levelStep: OptionalFixedAttribute<number, any>;
                      targetLevel: Attribute<null | number, any>;
                  };
              };
              flags: {
                  level: true;
              };
          }];
          features: {
              level: BitFlag;
              timeSync: BitFlag;
          };
          id: 129;
          name: "ValveConfigurationAndControl";
          revision: 1;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            defaultOpenDuration: WritableAttribute<null | number, any>;
            openDuration: Attribute<null | number, any>;
            remainingDuration: Attribute<null | number, any>;
            targetState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            valveFault: OptionalAttribute<TypeFromPartialBitSchema<{
                blocked: BitFlag;
                currentExceeded: BitFlag;
                generalFault: BitFlag;
                leaking: BitFlag;
                notConnected: BitFlag;
                shortCircuit: BitFlag;
            }>, any>;
        };
        commands: {
            close: Command<void, void, any>;
            open: Command<TypeFromFields<{
                openDuration: OptionalFieldType<null | number>;
                targetLevel: OptionalFieldType<number>;
            }>, void, any>;
        };
        events: {
            valveFault: OptionalEvent<TypeFromFields<{
                valveFault: FieldType<TypeFromPartialBitSchema<{
                    blocked: BitFlag;
                    currentExceeded: BitFlag;
                    generalFault: BitFlag;
                    leaking: BitFlag;
                    notConnected: BitFlag;
                    shortCircuit: BitFlag;
                }>>;
            }>, any>;
            valveStateChanged: OptionalEvent<TypeFromFields<{
                valveLevel: OptionalFieldType<number>;
                valveState: FieldType<ValveConfigurationAndControl.ValveState>;
            }>, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    autoCloseTime: Attribute<null | number | bigint, any>;
                };
            };
            flags: {
                timeSync: true;
            };
        }, {
            component: {
                attributes: {
                    currentLevel: Attribute<null | number, any>;
                    defaultOpenLevel: OptionalWritableAttribute<number, any>;
                    levelStep: OptionalFixedAttribute<number, any>;
                    targetLevel: Attribute<null | number, any>;
                };
            };
            flags: {
                level: true;
            };
        }];
        features: {
            level: BitFlag;
            timeSync: BitFlag;
        };
        id: 129;
        name: "ValveConfigurationAndControl";
        revision: 1;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods