Interface Complete

This cluster supports all ValveConfigurationAndControl features. It may support illegal feature combinations.

If you use this cluster you must manually specify which features are active and ensure the set of active features is legal per the Matter specification.

interface Complete {
    attributes: Merge<{
        acceptedCommandList: Attribute<CommandId[], never>;
        attributeList: Attribute<AttributeId[], never>;
        autoCloseTime: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                timeSync: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        currentLevel: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                level: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
        defaultOpenDuration: WritableAttribute<null | number, any>;
        defaultOpenLevel: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                level: boolean;
            }];
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            level: BitFlag;
            timeSync: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        levelStep: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                level: boolean;
            }];
        };
        openDuration: Attribute<null | number, any>;
        remainingDuration: Attribute<null | number, any>;
        targetLevel: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                level: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        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: undefined;
    features: {
        level: BitFlag;
        timeSync: BitFlag;
    };
    id: Branded<Branded<129, "ClusterId">, "ClusterId">;
    name: "ValveConfigurationAndControl";
    revision: 1;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            autoCloseTime: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSync: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clusterRevision: Attribute<number, never>;
            currentLevel: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    level: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            defaultOpenDuration: WritableAttribute<null | number, any>;
            defaultOpenLevel: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    level: boolean;
                }];
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                level: BitFlag;
                timeSync: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            levelStep: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    level: boolean;
                }];
            };
            openDuration: Attribute<null | number, any>;
            remainingDuration: Attribute<null | number, any>;
            targetLevel: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    level: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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>;
        };
        features: {
            level: BitFlag;
            timeSync: BitFlag;
        };
        id: Branded<129, "ClusterId">;
        name: "ValveConfigurationAndControl";
        revision: 1;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            autoCloseTime: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSync: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clusterRevision: Attribute<number, never>;
            currentLevel: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    level: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            defaultOpenDuration: WritableAttribute<null | number, any>;
            defaultOpenLevel: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    level: boolean;
                }];
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                level: BitFlag;
                timeSync: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            levelStep: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    level: boolean;
                }];
            };
            openDuration: Attribute<null | number, any>;
            remainingDuration: Attribute<null | number, any>;
            targetLevel: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    level: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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>;
        };
        features: {
            level: BitFlag;
            timeSync: BitFlag;
        };
        id: Branded<129, "ClusterId">;
        name: "ValveConfigurationAndControl";
        revision: 1;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            autoCloseTime: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSync: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clusterRevision: Attribute<number, never>;
            currentLevel: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    level: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            defaultOpenDuration: WritableAttribute<null | number, any>;
            defaultOpenLevel: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    level: boolean;
                }];
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                level: BitFlag;
                timeSync: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            levelStep: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    level: boolean;
                }];
            };
            openDuration: Attribute<null | number, any>;
            remainingDuration: Attribute<null | number, any>;
            targetLevel: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    level: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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>;
        };
        features: {
            level: BitFlag;
            timeSync: BitFlag;
        };
        id: Branded<129, "ClusterId">;
        name: "ValveConfigurationAndControl";
        revision: 1;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            attributeList: Attribute<AttributeId[], never>;
            autoCloseTime: Attribute<null | number | bigint, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    timeSync: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clusterRevision: Attribute<number, never>;
            currentLevel: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    level: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
            defaultOpenDuration: WritableAttribute<null | number, any>;
            defaultOpenLevel: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    level: boolean;
                }];
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                level: BitFlag;
                timeSync: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            levelStep: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    level: boolean;
                }];
            };
            openDuration: Attribute<null | number, any>;
            remainingDuration: Attribute<null | number, any>;
            targetLevel: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    level: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            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>;
        };
        features: {
            level: BitFlag;
            timeSync: BitFlag;
        };
        id: Branded<129, "ClusterId">;
        name: "ValveConfigurationAndControl";
        revision: 1;
    }>, SelectionT>;
}

Hierarchy (view full)

Identity<typeof ValveConfigurationAndControl.CompleteInstance>
- Complete

Index

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    acceptedCommandList: Attribute<CommandId[], never>;
    attributeList: Attribute<AttributeId[], never>;
    autoCloseTime: Attribute<null | number | bigint, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            timeSync: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    clusterRevision: Attribute<number, never>;
    currentLevel: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            level: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
    defaultOpenDuration: WritableAttribute<null | number, any>;
    defaultOpenLevel: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            level: boolean;
        }];
    };
    featureMap: Attribute<TypeFromPartialBitSchema<{
        level: BitFlag;
        timeSync: BitFlag;
    }>, never>;
    generatedCommandList: Attribute<CommandId[], never>;
    levelStep: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            level: boolean;
        }];
    };
    openDuration: Attribute<null | number, any>;
    remainingDuration: Attribute<null | number, any>;
    targetLevel: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            level: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    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

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

ReadonlyvalveFault: OptionalEvent<TypeFromFields<{
    valveFault: FieldType<TypeFromPartialBitSchema<{
        blocked: BitFlag;
        currentExceeded: BitFlag;
        generalFault: BitFlag;
        leaking: BitFlag;
        notConnected: BitFlag;
        shortCircuit: BitFlag;
    }>>;
}>, any>
This event shall be generated when the valve registers or clears a fault, e.g. not being able to transition to the requested target level or state.

See
MatterSpecification.v13.Cluster § 4.6.9.2
ReadonlyvalveStateChanged: OptionalEvent<TypeFromFields<{
valveLevel: OptionalFieldType<number>;
valveState: FieldType<ValveConfigurationAndControl.ValveState>;
}>, any>
This event shall be generated when the valve state changed. For level changes, after the end of movement, for state changes when the new state has been reached.

See
MatterSpecification.v13.Cluster § 4.6.9.1

extensions

extensions: undefined

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<Branded<129, "ClusterId">, "ClusterId">

name

revision

supportedFeatures

supportedFeatures: {}

unknown

Methods

alter

alter<const AlterationsT>(alterations): WithAlterations<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        attributeList: Attribute<AttributeId[], never>;
        autoCloseTime: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                timeSync: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        currentLevel: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                level: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
        defaultOpenDuration: WritableAttribute<null | number, any>;
        defaultOpenLevel: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                level: boolean;
            }];
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            level: BitFlag;
            timeSync: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        levelStep: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                level: boolean;
            }];
        };
        openDuration: Attribute<null | number, any>;
        remainingDuration: Attribute<null | number, any>;
        targetLevel: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                level: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        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>;
    };
    features: {
        level: BitFlag;
        timeSync: BitFlag;
    };
    id: Branded<129, "ClusterId">;
    name: "ValveConfigurationAndControl";
    revision: 1;
}>, AlterationsT>
Modify elements using ElementModifier.alter.
Type Parameters
- const AlterationsT extends Alterations<Of<{
      attributes: {
          acceptedCommandList: Attribute<CommandId[], never>;
          attributeList: Attribute<AttributeId[], never>;
          autoCloseTime: Attribute<null | number | bigint, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  timeSync: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          clusterRevision: Attribute<number, never>;
          currentLevel: Attribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  level: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
          defaultOpenDuration: WritableAttribute<null | number, any>;
          defaultOpenLevel: OptionalWritableAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  level: boolean;
              }];
          };
          featureMap: Attribute<TypeFromPartialBitSchema<{
              level: BitFlag;
              timeSync: BitFlag;
          }>, never>;
          generatedCommandList: Attribute<CommandId[], never>;
          levelStep: OptionalFixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  level: boolean;
              }];
          };
          openDuration: Attribute<null | number, any>;
          remainingDuration: Attribute<null | number, any>;
          targetLevel: Attribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  level: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          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>;
      };
      features: {
          level: BitFlag;
          timeSync: BitFlag;
      };
      id: Branded<129, "ClusterId">;
      name: "ValveConfigurationAndControl";
      revision: 1;
  }>>
Parameters
- alterations: AlterationsT
Returns WithAlterations<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        attributeList: Attribute<AttributeId[], never>;
        autoCloseTime: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                timeSync: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        currentLevel: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                level: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
        defaultOpenDuration: WritableAttribute<null | number, any>;
        defaultOpenLevel: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                level: boolean;
            }];
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            level: BitFlag;
            timeSync: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        levelStep: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                level: boolean;
            }];
        };
        openDuration: Attribute<null | number, any>;
        remainingDuration: Attribute<null | number, any>;
        targetLevel: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                level: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        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>;
    };
    features: {
        level: BitFlag;
        timeSync: BitFlag;
    };
    id: Branded<129, "ClusterId">;
    name: "ValveConfigurationAndControl";
    revision: 1;
}>, AlterationsT>
Inherited from Identity.alter
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:37

enable

enable<const FlagsT>(flags): WithFlags<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        attributeList: Attribute<AttributeId[], never>;
        autoCloseTime: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                timeSync: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        currentLevel: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                level: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
        defaultOpenDuration: WritableAttribute<null | number, any>;
        defaultOpenLevel: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                level: boolean;
            }];
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            level: BitFlag;
            timeSync: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        levelStep: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                level: boolean;
            }];
        };
        openDuration: Attribute<null | number, any>;
        remainingDuration: Attribute<null | number, any>;
        targetLevel: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                level: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        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>;
    };
    features: {
        level: BitFlag;
        timeSync: BitFlag;
    };
    id: Branded<129, "ClusterId">;
    name: "ValveConfigurationAndControl";
    revision: 1;
}>, FlagsT>
Modify elements using ElementModifier.enable.
Type Parameters
- const FlagsT extends ElementFlags<Of<{
      attributes: {
          acceptedCommandList: Attribute<CommandId[], never>;
          attributeList: Attribute<AttributeId[], never>;
          autoCloseTime: Attribute<null | number | bigint, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  timeSync: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          clusterRevision: Attribute<number, never>;
          currentLevel: Attribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  level: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
          defaultOpenDuration: WritableAttribute<null | number, any>;
          defaultOpenLevel: OptionalWritableAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  level: boolean;
              }];
          };
          featureMap: Attribute<TypeFromPartialBitSchema<{
              level: BitFlag;
              timeSync: BitFlag;
          }>, never>;
          generatedCommandList: Attribute<CommandId[], never>;
          levelStep: OptionalFixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  level: boolean;
              }];
          };
          openDuration: Attribute<null | number, any>;
          remainingDuration: Attribute<null | number, any>;
          targetLevel: Attribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  level: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          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>;
      };
      features: {
          level: BitFlag;
          timeSync: BitFlag;
      };
      id: Branded<129, "ClusterId">;
      name: "ValveConfigurationAndControl";
      revision: 1;
  }>>
Parameters
- flags: FlagsT
Returns WithFlags<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        attributeList: Attribute<AttributeId[], never>;
        autoCloseTime: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                timeSync: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        currentLevel: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                level: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
        defaultOpenDuration: WritableAttribute<null | number, any>;
        defaultOpenLevel: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                level: boolean;
            }];
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            level: BitFlag;
            timeSync: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        levelStep: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                level: boolean;
            }];
        };
        openDuration: Attribute<null | number, any>;
        remainingDuration: Attribute<null | number, any>;
        targetLevel: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                level: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        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>;
    };
    features: {
        level: BitFlag;
        timeSync: BitFlag;
    };
    id: Branded<129, "ClusterId">;
    name: "ValveConfigurationAndControl";
    revision: 1;
}>, FlagsT>
Inherited from Identity.enable
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:45

set

set<const ValuesT>(values): WithValues<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        attributeList: Attribute<AttributeId[], never>;
        autoCloseTime: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                timeSync: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        currentLevel: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                level: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
        defaultOpenDuration: WritableAttribute<null | number, any>;
        defaultOpenLevel: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                level: boolean;
            }];
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            level: BitFlag;
            timeSync: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        levelStep: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                level: boolean;
            }];
        };
        openDuration: Attribute<null | number, any>;
        remainingDuration: Attribute<null | number, any>;
        targetLevel: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                level: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        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>;
    };
    features: {
        level: BitFlag;
        timeSync: BitFlag;
    };
    id: Branded<129, "ClusterId">;
    name: "ValveConfigurationAndControl";
    revision: 1;
}>, ValuesT>
Modify elements using ElementModifier.set.
Type Parameters
- const ValuesT extends {
      autoCloseTime?: null | number | bigint;
      currentLevel?: null | number;
      currentState: null | number;
      defaultOpenDuration: null | number;
      defaultOpenLevel?: number;
      levelStep?: number;
      openDuration: null | number;
      remainingDuration: null | number;
      targetLevel?: null | number;
      targetState: null | number;
      valveFault?: {
          blocked?: boolean;
          currentExceeded?: boolean;
          generalFault?: boolean;
          leaking?: boolean;
          notConnected?: boolean;
          shortCircuit?: boolean;
      };
  }
Parameters
- values: ValuesT
Returns WithValues<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        attributeList: Attribute<AttributeId[], never>;
        autoCloseTime: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                timeSync: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        currentLevel: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                level: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
        defaultOpenDuration: WritableAttribute<null | number, any>;
        defaultOpenLevel: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                level: boolean;
            }];
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            level: BitFlag;
            timeSync: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        levelStep: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                level: boolean;
            }];
        };
        openDuration: Attribute<null | number, any>;
        remainingDuration: Attribute<null | number, any>;
        targetLevel: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                level: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        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>;
    };
    features: {
        level: BitFlag;
        timeSync: BitFlag;
    };
    id: Branded<129, "ClusterId">;
    name: "ValveConfigurationAndControl";
    revision: 1;
}>, ValuesT>
Inherited from Identity.set
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:41

with

with<const SelectionT>(...selection): Of<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        attributeList: Attribute<AttributeId[], never>;
        autoCloseTime: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                timeSync: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        currentLevel: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                level: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
        defaultOpenDuration: WritableAttribute<null | number, any>;
        defaultOpenLevel: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                level: boolean;
            }];
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            level: BitFlag;
            timeSync: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        levelStep: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                level: boolean;
            }];
        };
        openDuration: Attribute<null | number, any>;
        remainingDuration: Attribute<null | number, any>;
        targetLevel: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                level: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        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>;
    };
    features: {
        level: BitFlag;
        timeSync: BitFlag;
    };
    id: Branded<129, "ClusterId">;
    name: "ValveConfigurationAndControl";
    revision: 1;
}>, SelectionT>
Select features using ClusterComposer.compose.
Type Parameters
- const SelectionT extends FeatureSelection<Of<{
      attributes: {
          acceptedCommandList: Attribute<CommandId[], never>;
          attributeList: Attribute<AttributeId[], never>;
          autoCloseTime: Attribute<null | number | bigint, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  timeSync: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          clusterRevision: Attribute<number, never>;
          currentLevel: Attribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  level: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
          defaultOpenDuration: WritableAttribute<null | number, any>;
          defaultOpenLevel: OptionalWritableAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  level: boolean;
              }];
          };
          featureMap: Attribute<TypeFromPartialBitSchema<{
              level: BitFlag;
              timeSync: BitFlag;
          }>, never>;
          generatedCommandList: Attribute<CommandId[], never>;
          levelStep: OptionalFixedAttribute<number, any> & {
              isConditional: true;
              mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
              optional: true;
              optionalIf: [] | [{
                  level: boolean;
              }];
          };
          openDuration: Attribute<null | number, any>;
          remainingDuration: Attribute<null | number, any>;
          targetLevel: Attribute<null | number, any> & {
              isConditional: true;
              mandatoryIf: [] | [{
                  level: boolean;
              }];
              optional: true;
              optionalIf: [] | ConditionalFeatureList<BitSchema>;
          };
          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>;
      };
      features: {
          level: BitFlag;
          timeSync: BitFlag;
      };
      id: Branded<129, "ClusterId">;
      name: "ValveConfigurationAndControl";
      revision: 1;
  }>>
Parameters
- Rest...selection: SelectionT
Returns Of<Of<{
    attributes: {
        acceptedCommandList: Attribute<CommandId[], never>;
        attributeList: Attribute<AttributeId[], never>;
        autoCloseTime: Attribute<null | number | bigint, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                timeSync: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clusterRevision: Attribute<number, never>;
        currentLevel: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                level: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        currentState: Attribute<null | ValveConfigurationAndControl.ValveState, any>;
        defaultOpenDuration: WritableAttribute<null | number, any>;
        defaultOpenLevel: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                level: boolean;
            }];
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            level: BitFlag;
            timeSync: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        levelStep: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                level: boolean;
            }];
        };
        openDuration: Attribute<null | number, any>;
        remainingDuration: Attribute<null | number, any>;
        targetLevel: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                level: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        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>;
    };
    features: {
        level: BitFlag;
        timeSync: BitFlag;
    };
    id: Branded<129, "ClusterId">;
    name: "ValveConfigurationAndControl";
    revision: 1;
}>, SelectionT>
Inherited from Identity.with
- Defined in packages/types/dist/esm/cluster/mutation/MutableCluster.d.ts:33

Interface Complete

Hierarchy (view full)

Index

Properties

Methods

Properties

attributes

base

commands

Type declaration

Readonlyclose: Command<void, void, any>

See

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

See

events

Type declaration

ReadonlyvalveFault: OptionalEvent<TypeFromFields<{ valveFault: FieldType<TypeFromPartialBitSchema<{ blocked: BitFlag; currentExceeded: BitFlag; generalFault: BitFlag; leaking: BitFlag; notConnected: BitFlag; shortCircuit: BitFlag; }>>; }>, any>

See

ReadonlyvalveStateChanged: OptionalEvent<TypeFromFields<{ valveLevel: OptionalFieldType<number>; valveState: FieldType<ValveConfigurationAndControl.ValveState>; }>, any>

See

extensions

features

Type declaration

Readonlylevel: BitFlag

See

ReadonlytimeSync: BitFlag

See

id

name

revision

supportedFeatures

unknown

Methods

alter

Type Parameters

Parameters

enable

Type Parameters

Parameters

set

Type Parameters

Parameters

with

Type Parameters

Parameters

Settings

On This Page

`Readonly`close: Command<void, void, any>

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

`Readonly`valveFault: OptionalEvent<TypeFromFields<{
valveFault: FieldType<TypeFromPartialBitSchema<{
blocked: BitFlag;
currentExceeded: BitFlag;
generalFault: BitFlag;
leaking: BitFlag;
notConnected: BitFlag;
shortCircuit: BitFlag;
}>>;
}>, any>

`Readonly`valveStateChanged: OptionalEvent<TypeFromFields<{
valveLevel: OptionalFieldType<number>;
valveState: FieldType<ValveConfigurationAndControl.ValveState>;
}>, any>

`Readonly`level: BitFlag

`Readonly`timeSync: BitFlag