This cluster supports all PumpConfigurationAndControl 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<{
        capacity: Attribute<null | number, any>;
        controlMode: OptionalWritableAttribute<PumpConfigurationAndControl.ControlMode, any>;
        effectiveControlMode: Attribute<PumpConfigurationAndControl.ControlMode, any>;
        effectiveOperationMode: Attribute<PumpConfigurationAndControl.OperationMode, any>;
        lifetimeEnergyConsumed: OptionalWritableAttribute<null | number, any>;
        lifetimeRunningHours: OptionalWritableAttribute<null | number, any>;
        maxCompPressure: OptionalFixedAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                compensatedPressure: boolean;
            }];
            optional: true;
            optionalIf: [] | [{
                automatic: boolean;
            }];
        };
        maxConstFlow: OptionalFixedAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                constantFlow: boolean;
            }];
            optional: true;
            optionalIf: [] | [{
                automatic: boolean;
            }];
        };
        maxConstPressure: FixedAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                constantPressure: boolean;
            }];
            optional: true;
            optionalIf: [] | [{
                automatic: boolean;
            }];
        };
        maxConstSpeed: OptionalFixedAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                constantSpeed: boolean;
            }];
            optional: true;
            optionalIf: [] | [{
                automatic: boolean;
            }];
        };
        maxConstTemp: OptionalFixedAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                constantTemperature: boolean;
            }];
            optional: true;
            optionalIf: [] | [{
                automatic: boolean;
            }];
        };
        maxFlow: FixedAttribute<null | number, any>;
        maxPressure: FixedAttribute<null | number, any>;
        maxSpeed: FixedAttribute<null | number, any>;
        minCompPressure: OptionalFixedAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                compensatedPressure: boolean;
            }];
            optional: true;
            optionalIf: [] | [{
                automatic: boolean;
            }];
        };
        minConstFlow: OptionalFixedAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                constantFlow: boolean;
            }];
            optional: true;
            optionalIf: [] | [{
                automatic: boolean;
            }];
        };
        minConstPressure: FixedAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                constantPressure: boolean;
            }];
            optional: true;
            optionalIf: [] | [{
                automatic: boolean;
            }];
        };
        minConstSpeed: OptionalFixedAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                constantSpeed: boolean;
            }];
            optional: true;
            optionalIf: [] | [{
                automatic: boolean;
            }];
        };
        minConstTemp: OptionalFixedAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                constantTemperature: boolean;
            }];
            optional: true;
            optionalIf: [] | [{
                automatic: boolean;
            }];
        };
        operationMode: WritableAttribute<PumpConfigurationAndControl.OperationMode, any>;
        power: OptionalAttribute<null | number, any>;
        pumpStatus: OptionalAttribute<TypeFromPartialBitSchema<{
            deviceFault: BitFlag;
            localOverride: BitFlag;
            remoteFlow: BitFlag;
            remotePressure: BitFlag;
            remoteTemperature: BitFlag;
            running: BitFlag;
            speedHigh: BitFlag;
            speedLow: BitFlag;
            supplyFault: BitFlag;
        }>, any>;
        speed: OptionalAttribute<null | number, any>;
    }, GlobalAttributes<{
        automatic: BitFlag;
        compensatedPressure: BitFlag;
        constantFlow: BitFlag;
        constantPressure: BitFlag;
        constantSpeed: BitFlag;
        constantTemperature: BitFlag;
        localOperation: BitFlag;
    }>>;
    base: undefined;
    commands: {};
    events: {
        airDetection: OptionalEvent<void, any>;
        dryRunning: OptionalEvent<void, any>;
        electronicFatalFailure: OptionalEvent<void, any>;
        electronicNonFatalFailure: OptionalEvent<void, any>;
        electronicTemperatureHigh: OptionalEvent<void, any>;
        generalFault: OptionalEvent<void, any>;
        leakage: OptionalEvent<void, any>;
        motorTemperatureHigh: OptionalEvent<void, any>;
        powerMissingPhase: OptionalEvent<void, any>;
        pumpBlocked: OptionalEvent<void, any>;
        pumpMotorFatalFailure: OptionalEvent<void, any>;
        sensorFailure: OptionalEvent<void, any>;
        supplyVoltageHigh: OptionalEvent<void, any>;
        supplyVoltageLow: OptionalEvent<void, any>;
        systemPressureHigh: OptionalEvent<void, any>;
        systemPressureLow: OptionalEvent<void, any>;
        turbineOperation: OptionalEvent<void, any>;
    };
    extensions: undefined;
    features: {
        automatic: BitFlag;
        compensatedPressure: BitFlag;
        constantFlow: BitFlag;
        constantPressure: BitFlag;
        constantSpeed: BitFlag;
        constantTemperature: BitFlag;
        localOperation: BitFlag;
    };
    id: Branded<512, "ClusterId">;
    name: "PumpConfigurationAndControl";
    revision: 4;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            capacity: Attribute<null | number, any>;
            controlMode: OptionalWritableAttribute<PumpConfigurationAndControl.ControlMode, any>;
            effectiveControlMode: Attribute<PumpConfigurationAndControl.ControlMode, any>;
            effectiveOperationMode: Attribute<PumpConfigurationAndControl.OperationMode, any>;
            lifetimeEnergyConsumed: OptionalWritableAttribute<null | number, any>;
            lifetimeRunningHours: OptionalWritableAttribute<null | number, any>;
            maxCompPressure: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    compensatedPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstFlow: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantFlow: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstPressure: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstSpeed: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstTemp: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxFlow: FixedAttribute<null | number, any>;
            maxPressure: FixedAttribute<null | number, any>;
            maxSpeed: FixedAttribute<null | number, any>;
            minCompPressure: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    compensatedPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstFlow: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantFlow: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstPressure: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstSpeed: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstTemp: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            operationMode: WritableAttribute<PumpConfigurationAndControl.OperationMode, any>;
            power: OptionalAttribute<null | number, any>;
            pumpStatus: OptionalAttribute<TypeFromPartialBitSchema<{
                deviceFault: BitFlag;
                localOverride: BitFlag;
                remoteFlow: BitFlag;
                remotePressure: BitFlag;
                remoteTemperature: BitFlag;
                running: BitFlag;
                speedHigh: BitFlag;
                speedLow: BitFlag;
                supplyFault: BitFlag;
            }>, any>;
            speed: OptionalAttribute<null | number, any>;
        };
        events: {
            airDetection: OptionalEvent<void, any>;
            dryRunning: OptionalEvent<void, any>;
            electronicFatalFailure: OptionalEvent<void, any>;
            electronicNonFatalFailure: OptionalEvent<void, any>;
            electronicTemperatureHigh: OptionalEvent<void, any>;
            generalFault: OptionalEvent<void, any>;
            leakage: OptionalEvent<void, any>;
            motorTemperatureHigh: OptionalEvent<void, any>;
            powerMissingPhase: OptionalEvent<void, any>;
            pumpBlocked: OptionalEvent<void, any>;
            pumpMotorFatalFailure: OptionalEvent<void, any>;
            sensorFailure: OptionalEvent<void, any>;
            supplyVoltageHigh: OptionalEvent<void, any>;
            supplyVoltageLow: OptionalEvent<void, any>;
            systemPressureHigh: OptionalEvent<void, any>;
            systemPressureLow: OptionalEvent<void, any>;
            turbineOperation: OptionalEvent<void, any>;
        };
        features: {
            automatic: BitFlag;
            compensatedPressure: BitFlag;
            constantFlow: BitFlag;
            constantPressure: BitFlag;
            constantSpeed: BitFlag;
            constantTemperature: BitFlag;
            localOperation: BitFlag;
        };
        id: 512;
        name: "PumpConfigurationAndControl";
        revision: 4;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            capacity: Attribute<null | number, any>;
            controlMode: OptionalWritableAttribute<PumpConfigurationAndControl.ControlMode, any>;
            effectiveControlMode: Attribute<PumpConfigurationAndControl.ControlMode, any>;
            effectiveOperationMode: Attribute<PumpConfigurationAndControl.OperationMode, any>;
            lifetimeEnergyConsumed: OptionalWritableAttribute<null | number, any>;
            lifetimeRunningHours: OptionalWritableAttribute<null | number, any>;
            maxCompPressure: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    compensatedPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstFlow: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantFlow: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstPressure: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstSpeed: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstTemp: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxFlow: FixedAttribute<null | number, any>;
            maxPressure: FixedAttribute<null | number, any>;
            maxSpeed: FixedAttribute<null | number, any>;
            minCompPressure: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    compensatedPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstFlow: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantFlow: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstPressure: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstSpeed: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstTemp: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            operationMode: WritableAttribute<PumpConfigurationAndControl.OperationMode, any>;
            power: OptionalAttribute<null | number, any>;
            pumpStatus: OptionalAttribute<TypeFromPartialBitSchema<{
                deviceFault: BitFlag;
                localOverride: BitFlag;
                remoteFlow: BitFlag;
                remotePressure: BitFlag;
                remoteTemperature: BitFlag;
                running: BitFlag;
                speedHigh: BitFlag;
                speedLow: BitFlag;
                supplyFault: BitFlag;
            }>, any>;
            speed: OptionalAttribute<null | number, any>;
        };
        events: {
            airDetection: OptionalEvent<void, any>;
            dryRunning: OptionalEvent<void, any>;
            electronicFatalFailure: OptionalEvent<void, any>;
            electronicNonFatalFailure: OptionalEvent<void, any>;
            electronicTemperatureHigh: OptionalEvent<void, any>;
            generalFault: OptionalEvent<void, any>;
            leakage: OptionalEvent<void, any>;
            motorTemperatureHigh: OptionalEvent<void, any>;
            powerMissingPhase: OptionalEvent<void, any>;
            pumpBlocked: OptionalEvent<void, any>;
            pumpMotorFatalFailure: OptionalEvent<void, any>;
            sensorFailure: OptionalEvent<void, any>;
            supplyVoltageHigh: OptionalEvent<void, any>;
            supplyVoltageLow: OptionalEvent<void, any>;
            systemPressureHigh: OptionalEvent<void, any>;
            systemPressureLow: OptionalEvent<void, any>;
            turbineOperation: OptionalEvent<void, any>;
        };
        features: {
            automatic: BitFlag;
            compensatedPressure: BitFlag;
            constantFlow: BitFlag;
            constantPressure: BitFlag;
            constantSpeed: BitFlag;
            constantTemperature: BitFlag;
            localOperation: BitFlag;
        };
        id: 512;
        name: "PumpConfigurationAndControl";
        revision: 4;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            capacity: Attribute<null | number, any>;
            controlMode: OptionalWritableAttribute<PumpConfigurationAndControl.ControlMode, any>;
            effectiveControlMode: Attribute<PumpConfigurationAndControl.ControlMode, any>;
            effectiveOperationMode: Attribute<PumpConfigurationAndControl.OperationMode, any>;
            lifetimeEnergyConsumed: OptionalWritableAttribute<null | number, any>;
            lifetimeRunningHours: OptionalWritableAttribute<null | number, any>;
            maxCompPressure: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    compensatedPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstFlow: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantFlow: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstPressure: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstSpeed: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstTemp: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxFlow: FixedAttribute<null | number, any>;
            maxPressure: FixedAttribute<null | number, any>;
            maxSpeed: FixedAttribute<null | number, any>;
            minCompPressure: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    compensatedPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstFlow: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantFlow: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstPressure: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstSpeed: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstTemp: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            operationMode: WritableAttribute<PumpConfigurationAndControl.OperationMode, any>;
            power: OptionalAttribute<null | number, any>;
            pumpStatus: OptionalAttribute<TypeFromPartialBitSchema<{
                deviceFault: BitFlag;
                localOverride: BitFlag;
                remoteFlow: BitFlag;
                remotePressure: BitFlag;
                remoteTemperature: BitFlag;
                running: BitFlag;
                speedHigh: BitFlag;
                speedLow: BitFlag;
                supplyFault: BitFlag;
            }>, any>;
            speed: OptionalAttribute<null | number, any>;
        };
        events: {
            airDetection: OptionalEvent<void, any>;
            dryRunning: OptionalEvent<void, any>;
            electronicFatalFailure: OptionalEvent<void, any>;
            electronicNonFatalFailure: OptionalEvent<void, any>;
            electronicTemperatureHigh: OptionalEvent<void, any>;
            generalFault: OptionalEvent<void, any>;
            leakage: OptionalEvent<void, any>;
            motorTemperatureHigh: OptionalEvent<void, any>;
            powerMissingPhase: OptionalEvent<void, any>;
            pumpBlocked: OptionalEvent<void, any>;
            pumpMotorFatalFailure: OptionalEvent<void, any>;
            sensorFailure: OptionalEvent<void, any>;
            supplyVoltageHigh: OptionalEvent<void, any>;
            supplyVoltageLow: OptionalEvent<void, any>;
            systemPressureHigh: OptionalEvent<void, any>;
            systemPressureLow: OptionalEvent<void, any>;
            turbineOperation: OptionalEvent<void, any>;
        };
        features: {
            automatic: BitFlag;
            compensatedPressure: BitFlag;
            constantFlow: BitFlag;
            constantPressure: BitFlag;
            constantSpeed: BitFlag;
            constantTemperature: BitFlag;
            localOperation: BitFlag;
        };
        id: 512;
        name: "PumpConfigurationAndControl";
        revision: 4;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            capacity: Attribute<null | number, any>;
            controlMode: OptionalWritableAttribute<PumpConfigurationAndControl.ControlMode, any>;
            effectiveControlMode: Attribute<PumpConfigurationAndControl.ControlMode, any>;
            effectiveOperationMode: Attribute<PumpConfigurationAndControl.OperationMode, any>;
            lifetimeEnergyConsumed: OptionalWritableAttribute<null | number, any>;
            lifetimeRunningHours: OptionalWritableAttribute<null | number, any>;
            maxCompPressure: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    compensatedPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstFlow: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantFlow: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstPressure: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstSpeed: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstTemp: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxFlow: FixedAttribute<null | number, any>;
            maxPressure: FixedAttribute<null | number, any>;
            maxSpeed: FixedAttribute<null | number, any>;
            minCompPressure: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    compensatedPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstFlow: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantFlow: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstPressure: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstSpeed: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstTemp: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            operationMode: WritableAttribute<PumpConfigurationAndControl.OperationMode, any>;
            power: OptionalAttribute<null | number, any>;
            pumpStatus: OptionalAttribute<TypeFromPartialBitSchema<{
                deviceFault: BitFlag;
                localOverride: BitFlag;
                remoteFlow: BitFlag;
                remotePressure: BitFlag;
                remoteTemperature: BitFlag;
                running: BitFlag;
                speedHigh: BitFlag;
                speedLow: BitFlag;
                supplyFault: BitFlag;
            }>, any>;
            speed: OptionalAttribute<null | number, any>;
        };
        events: {
            airDetection: OptionalEvent<void, any>;
            dryRunning: OptionalEvent<void, any>;
            electronicFatalFailure: OptionalEvent<void, any>;
            electronicNonFatalFailure: OptionalEvent<void, any>;
            electronicTemperatureHigh: OptionalEvent<void, any>;
            generalFault: OptionalEvent<void, any>;
            leakage: OptionalEvent<void, any>;
            motorTemperatureHigh: OptionalEvent<void, any>;
            powerMissingPhase: OptionalEvent<void, any>;
            pumpBlocked: OptionalEvent<void, any>;
            pumpMotorFatalFailure: OptionalEvent<void, any>;
            sensorFailure: OptionalEvent<void, any>;
            supplyVoltageHigh: OptionalEvent<void, any>;
            supplyVoltageLow: OptionalEvent<void, any>;
            systemPressureHigh: OptionalEvent<void, any>;
            systemPressureLow: OptionalEvent<void, any>;
            turbineOperation: OptionalEvent<void, any>;
        };
        features: {
            automatic: BitFlag;
            compensatedPressure: BitFlag;
            constantFlow: BitFlag;
            constantPressure: BitFlag;
            constantSpeed: BitFlag;
            constantTemperature: BitFlag;
            localOperation: BitFlag;
        };
        id: 512;
        name: "PumpConfigurationAndControl";
        revision: 4;
    }>, SelectionT>;
}

Hierarchy (view full)

Properties

attributes: Merge<{
    capacity: Attribute<null | number, any>;
    controlMode: OptionalWritableAttribute<PumpConfigurationAndControl.ControlMode, any>;
    effectiveControlMode: Attribute<PumpConfigurationAndControl.ControlMode, any>;
    effectiveOperationMode: Attribute<PumpConfigurationAndControl.OperationMode, any>;
    lifetimeEnergyConsumed: OptionalWritableAttribute<null | number, any>;
    lifetimeRunningHours: OptionalWritableAttribute<null | number, any>;
    maxCompPressure: OptionalFixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            compensatedPressure: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            automatic: boolean;
        }];
    };
    maxConstFlow: OptionalFixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            constantFlow: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            automatic: boolean;
        }];
    };
    maxConstPressure: FixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            constantPressure: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            automatic: boolean;
        }];
    };
    maxConstSpeed: OptionalFixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            constantSpeed: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            automatic: boolean;
        }];
    };
    maxConstTemp: OptionalFixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            constantTemperature: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            automatic: boolean;
        }];
    };
    maxFlow: FixedAttribute<null | number, any>;
    maxPressure: FixedAttribute<null | number, any>;
    maxSpeed: FixedAttribute<null | number, any>;
    minCompPressure: OptionalFixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            compensatedPressure: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            automatic: boolean;
        }];
    };
    minConstFlow: OptionalFixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            constantFlow: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            automatic: boolean;
        }];
    };
    minConstPressure: FixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            constantPressure: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            automatic: boolean;
        }];
    };
    minConstSpeed: OptionalFixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            constantSpeed: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            automatic: boolean;
        }];
    };
    minConstTemp: OptionalFixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            constantTemperature: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            automatic: boolean;
        }];
    };
    operationMode: WritableAttribute<PumpConfigurationAndControl.OperationMode, any>;
    power: OptionalAttribute<null | number, any>;
    pumpStatus: OptionalAttribute<TypeFromPartialBitSchema<{
        deviceFault: BitFlag;
        localOverride: BitFlag;
        remoteFlow: BitFlag;
        remotePressure: BitFlag;
        remoteTemperature: BitFlag;
        running: BitFlag;
        speedHigh: BitFlag;
        speedLow: BitFlag;
        supplyFault: BitFlag;
    }>, any>;
    speed: OptionalAttribute<null | number, any>;
}, GlobalAttributes<{
    automatic: BitFlag;
    compensatedPressure: BitFlag;
    constantFlow: BitFlag;
    constantPressure: BitFlag;
    constantSpeed: BitFlag;
    constantTemperature: BitFlag;
    localOperation: BitFlag;
}>>

Type declaration

  • Readonlycapacity: Attribute<null | number, any>

    This attribute specifies the actual capacity of the pump as a percentage of the effective maximum setpoint value. It is updated dynamically as the speed of the pump changes.

    If the value is not available (the measurement or estimation of the speed is done in the pump), this attribute will indicate the null value.

    Valid range is 0 % to 163.835% (0.005 % granularity). Although this attribute is a signed value, values of capacity less than zero have no physical meaning.

    MatterSpecification.v13.Cluster § 4.2.7.17

  • ReadonlycontrolMode: OptionalWritableAttribute<PumpConfigurationAndControl.ControlMode, any>

    This attribute specifies the control mode of the pump as defined in ControlModeEnum.

    See the OperationMode attribute for a detailed description of the operation and control of the

    pump.

    ControlMode may be changed at any time, even when the pump is running. The behavior of the pump at the point of changing is vendor-specific.

    In the case a device does not support a specific control mode, the write interaction to this attribute with an unsupported control mode value shall be ignored and a response containing the status of CONSTRAINT_ERROR shall be returned.

    MatterSpecification.v13.Cluster § 4.2.7.23

  • ReadonlyeffectiveControlMode: Attribute<PumpConfigurationAndControl.ControlMode, any>

    This attribute specifies the current effective control mode of the pump as defined in ControlModeEnum.

    This attribute contains the control mode that currently applies to the pump. It will have the value of the ControlMode attribute, unless one of the following points are true:

    • The ControlMode attribute is set to Automatic. In this case, the value of the EffectiveControlMode shall match the behavior of the pump.

    • A remote sensor is used as the sensor for regulation of the pump. In this case, EffectiveControlMode will display ConstantPressure, ConstantFlow or ConstantTemperature if the remote sensor is a pressure sensor, a flow sensor or a temperature sensor respectively, regardless of the value of the ControlMode attribute.

    In case the ControlMode attribute is not included on the device and no remote sensors are connected, the value of the EffectiveControlMode shall match the vendor-specific behavior of the pump.

    See OperationMode and ControlMode attributes for detailed a description of the operation and control of the pump.

    MatterSpecification.v13.Cluster § 4.2.7.16

  • ReadonlyeffectiveOperationMode: Attribute<PumpConfigurationAndControl.OperationMode, any>

    This attribute specifies current effective operation mode of the pump as defined in OperationModeEnum.

    The value of the EffectiveOperationMode attribute is the same as the OperationMode attribute, unless one of the following points are true:

    • The pump is physically set to run with the local settings

    • The LocalOverride bit in the PumpStatus attribute is set,

    See OperationMode and ControlMode attributes for a detailed description of the operation and control of the pump.

    MatterSpecification.v13.Cluster § 4.2.7.15

  • ReadonlylifetimeEnergyConsumed: OptionalWritableAttribute<null | number, any>

    This attribute specifies the accumulated energy consumption of the pump through the entire lifetime of the pump in kWh. The value of the LifetimeEnergyConsumed attribute is updated dynamically as the energy consumption of the pump increases. If LifetimeEnergyConsumed rises above maximum value it “rolls over” and starts at 0 (zero).

    This attribute is writeable, in order to allow setting to an appropriate value after maintenance.

    Valid range is 0 kWh to 4,294,967,294 kWh.

    Null if the value is unknown.

    MatterSpecification.v13.Cluster § 4.2.7.21

  • ReadonlylifetimeRunningHours: OptionalWritableAttribute<null | number, any>

    This attribute specifies the accumulated number of hours that the pump has been powered and the motor has been running. It is updated dynamically as it increases. It is preserved over power cycles of the pump. If LifeTimeRunningHours rises above maximum value it “rolls over” and starts at 0 (zero).

    This attribute is writeable, in order to allow setting to an appropriate value after maintenance. If

    the value is not available, this attribute will indicate the null value. Valid range is 0 to 16,777,214 hrs.

    MatterSpecification.v13.Cluster § 4.2.7.19

  • ReadonlymaxCompPressure: OptionalFixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            compensatedPressure: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            automatic: boolean;
        }];
    }
  • ReadonlymaxConstFlow: OptionalFixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            constantFlow: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            automatic: boolean;
        }];
    }
  • ReadonlymaxConstPressure: FixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            constantPressure: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            automatic: boolean;
        }];
    }
  • ReadonlymaxConstSpeed: OptionalFixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            constantSpeed: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            automatic: boolean;
        }];
    }
  • ReadonlymaxConstTemp: OptionalFixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            constantTemperature: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            automatic: boolean;
        }];
    }
  • ReadonlymaxFlow: FixedAttribute<null | number, any>

    This attribute specifies the maximum flow the pump can achieve. It is a physical limit, and does not apply to any specific control mode or operation mode.

    Valid range is 0 m/h to 6,553.4 m/h (steps of 0.1 m/h). Null if the value is invalid.

    MatterSpecification.v13.Cluster § 4.2.7.3

  • ReadonlymaxPressure: FixedAttribute<null | number, any>

    This attribute specifies the maximum pressure the pump can achieve. It is a physical limit, and does not apply to any specific control mode or operation mode.

    Valid range is -3,276.7 kPa to 3,276.7 kPa (steps of 0.1 kPa). Null if the value is invalid.

    MatterSpecification.v13.Cluster § 4.2.7.1

  • ReadonlymaxSpeed: FixedAttribute<null | number, any>

    This attribute specifies the maximum speed the pump can achieve. It is a physical limit, and does not apply to any specific control mode or operation mode.

    Valid range is 0 to 65,534 RPM (steps of 1 RPM). Null if the value is invalid.

    MatterSpecification.v13.Cluster § 4.2.7.2

  • ReadonlyminCompPressure: OptionalFixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            compensatedPressure: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            automatic: boolean;
        }];
    }
  • ReadonlyminConstFlow: OptionalFixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            constantFlow: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            automatic: boolean;
        }];
    }
  • ReadonlyminConstPressure: FixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            constantPressure: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            automatic: boolean;
        }];
    }
  • ReadonlyminConstSpeed: OptionalFixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            constantSpeed: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            automatic: boolean;
        }];
    }
  • ReadonlyminConstTemp: OptionalFixedAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            constantTemperature: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            automatic: boolean;
        }];
    }
  • ReadonlyoperationMode: WritableAttribute<PumpConfigurationAndControl.OperationMode, any>

    This attribute specifies the operation mode of the pump as defined in OperationModeEnum.

    The actual operating mode of the pump is a result of the setting of the attributes OperationMode, ControlMode and the optional connection of a remote sensor. The operation and control is prioritized as shown in the scheme below:

    Priority Scheme of Pump Operation and Control

    If this attribute is Maximum, Minimum or Local, the OperationMode attribute decides how the pump is operated.

    If this attribute is Normal and a remote sensor is connected to the pump, the type of the remote sensor decides the control mode of the pump. A connected remote pressure sensor will make the pump run in control mode Constant pressure and vice versa for flow and temperature type sensors. This is regardless of the setting of the ControlMode attribute.

    If this attribute is Normal and no remote sensor is connected, the control mode of the pump is decided by the ControlMode attribute.

    OperationMode may be changed at any time, even when the pump is running. The behavior of the pump at the point of changing the value of this attribute is vendor-specific.

    In the case a device does not support a specific operation mode, the write interaction to this attribute with an unsupported operation mode value shall be ignored and a response containing the status of CONSTRAINT_ERROR shall be returned.

    MatterSpecification.v13.Cluster § 4.2.7.22

  • Readonlypower: OptionalAttribute<null | number, any>

    This attribute specifies the actual power consumption of the pump in Watts. The value of this attribute is updated dynamically as the power consumption of the pump changes.

    This attribute is read only. If the value is not available (the measurement of power consumption is not done in the pump), this attribute will indicate the null value.

    Valid range is 0 to 16,777,214 Watts.

    MatterSpecification.v13.Cluster § 4.2.7.20

  • ReadonlypumpStatus: OptionalAttribute<TypeFromPartialBitSchema<{
        deviceFault: BitFlag;
        localOverride: BitFlag;
        remoteFlow: BitFlag;
        remotePressure: BitFlag;
        remoteTemperature: BitFlag;
        running: BitFlag;
        speedHigh: BitFlag;
        speedLow: BitFlag;
        supplyFault: BitFlag;
    }>, any>

    This attribute specifies the activity status of the pump functions as listed in PumpStatusBitmap. Where a pump controller function is active, the corresponding bit shall be set to 1. Where a pump controller function is not active, the corresponding bit shall be set to 0.

    MatterSpecification.v13.Cluster § 4.2.7.14

  • Readonlyspeed: OptionalAttribute<null | number, any>

    This attribute specifies the actual speed of the pump measured in RPM. It is updated dynamically as the speed of the pump changes.

    If the value is not available (the measurement or estimation of the speed is done in the pump), this attribute will indicate the null value.

    Valid range is 0 to 65.534 RPM.

    MatterSpecification.v13.Cluster § 4.2.7.18

base: undefined
commands: {}
events: {
    airDetection: OptionalEvent<void, any>;
    dryRunning: OptionalEvent<void, any>;
    electronicFatalFailure: OptionalEvent<void, any>;
    electronicNonFatalFailure: OptionalEvent<void, any>;
    electronicTemperatureHigh: OptionalEvent<void, any>;
    generalFault: OptionalEvent<void, any>;
    leakage: OptionalEvent<void, any>;
    motorTemperatureHigh: OptionalEvent<void, any>;
    powerMissingPhase: OptionalEvent<void, any>;
    pumpBlocked: OptionalEvent<void, any>;
    pumpMotorFatalFailure: OptionalEvent<void, any>;
    sensorFailure: OptionalEvent<void, any>;
    supplyVoltageHigh: OptionalEvent<void, any>;
    supplyVoltageLow: OptionalEvent<void, any>;
    systemPressureHigh: OptionalEvent<void, any>;
    systemPressureLow: OptionalEvent<void, any>;
    turbineOperation: OptionalEvent<void, any>;
}

Type declaration

  • ReadonlyairDetection: OptionalEvent<void, any>

    MatterSpecification.v13.Cluster § 4.2.8

  • ReadonlydryRunning: OptionalEvent<void, any>

    MatterSpecification.v13.Cluster § 4.2.8

  • ReadonlyelectronicFatalFailure: OptionalEvent<void, any>

    MatterSpecification.v13.Cluster § 4.2.8

  • ReadonlyelectronicNonFatalFailure: OptionalEvent<void, any>

    MatterSpecification.v13.Cluster § 4.2.8

  • ReadonlyelectronicTemperatureHigh: OptionalEvent<void, any>

    MatterSpecification.v13.Cluster § 4.2.8

  • ReadonlygeneralFault: OptionalEvent<void, any>

    MatterSpecification.v13.Cluster § 4.2.8

  • Readonlyleakage: OptionalEvent<void, any>

    MatterSpecification.v13.Cluster § 4.2.8

  • ReadonlymotorTemperatureHigh: OptionalEvent<void, any>

    MatterSpecification.v13.Cluster § 4.2.8

  • ReadonlypowerMissingPhase: OptionalEvent<void, any>

    MatterSpecification.v13.Cluster § 4.2.8

  • ReadonlypumpBlocked: OptionalEvent<void, any>

    MatterSpecification.v13.Cluster § 4.2.8

  • ReadonlypumpMotorFatalFailure: OptionalEvent<void, any>

    MatterSpecification.v13.Cluster § 4.2.8

  • ReadonlysensorFailure: OptionalEvent<void, any>

    MatterSpecification.v13.Cluster § 4.2.8

  • ReadonlysupplyVoltageHigh: OptionalEvent<void, any>

    MatterSpecification.v13.Cluster § 4.2.8

  • ReadonlysupplyVoltageLow: OptionalEvent<void, any>

    MatterSpecification.v13.Cluster § 4.2.8

  • ReadonlysystemPressureHigh: OptionalEvent<void, any>

    MatterSpecification.v13.Cluster § 4.2.8

  • ReadonlysystemPressureLow: OptionalEvent<void, any>

    MatterSpecification.v13.Cluster § 4.2.8

  • ReadonlyturbineOperation: OptionalEvent<void, any>

    MatterSpecification.v13.Cluster § 4.2.8

extensions: undefined
features: {
    automatic: BitFlag;
    compensatedPressure: BitFlag;
    constantFlow: BitFlag;
    constantPressure: BitFlag;
    constantSpeed: BitFlag;
    constantTemperature: BitFlag;
    localOperation: BitFlag;
}

Type declaration

  • Readonlyautomatic: BitFlag

    Automatic

    Supports operating in automatic mode

  • ReadonlycompensatedPressure: BitFlag

    CompensatedPressure

    Supports operating in compensated pressure mode

  • ReadonlyconstantFlow: BitFlag

    ConstantFlow

    Supports operating in constant flow mode

  • ReadonlyconstantPressure: BitFlag

    ConstantPressure

    Supports operating in constant pressure mode

  • ReadonlyconstantSpeed: BitFlag

    ConstantSpeed

    Supports operating in constant speed mode

  • ReadonlyconstantTemperature: BitFlag

    ConstantTemperature

    Supports operating in constant temperature mode

  • ReadonlylocalOperation: BitFlag

    LocalOperation

    Supports operating using local settings

id: Branded<512, "ClusterId">
name
revision
supportedFeatures: {}
unknown

Methods

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              capacity: Attribute<null | number, any>;
              controlMode: OptionalWritableAttribute<PumpConfigurationAndControl.ControlMode, any>;
              effectiveControlMode: Attribute<PumpConfigurationAndControl.ControlMode, any>;
              effectiveOperationMode: Attribute<PumpConfigurationAndControl.OperationMode, any>;
              lifetimeEnergyConsumed: OptionalWritableAttribute<null | number, any>;
              lifetimeRunningHours: OptionalWritableAttribute<null | number, any>;
              maxCompPressure: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      compensatedPressure: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              maxConstFlow: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantFlow: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              maxConstPressure: FixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantPressure: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              maxConstSpeed: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantSpeed: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              maxConstTemp: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantTemperature: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              maxFlow: FixedAttribute<null | number, any>;
              maxPressure: FixedAttribute<null | number, any>;
              maxSpeed: FixedAttribute<null | number, any>;
              minCompPressure: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      compensatedPressure: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              minConstFlow: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantFlow: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              minConstPressure: FixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantPressure: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              minConstSpeed: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantSpeed: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              minConstTemp: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantTemperature: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              operationMode: WritableAttribute<PumpConfigurationAndControl.OperationMode, any>;
              power: OptionalAttribute<null | number, any>;
              pumpStatus: OptionalAttribute<TypeFromPartialBitSchema<{
                  deviceFault: BitFlag;
                  localOverride: BitFlag;
                  remoteFlow: BitFlag;
                  remotePressure: BitFlag;
                  remoteTemperature: BitFlag;
                  running: BitFlag;
                  speedHigh: BitFlag;
                  speedLow: BitFlag;
                  supplyFault: BitFlag;
              }>, any>;
              speed: OptionalAttribute<null | number, any>;
          };
          events: {
              airDetection: OptionalEvent<void, any>;
              dryRunning: OptionalEvent<void, any>;
              electronicFatalFailure: OptionalEvent<void, any>;
              electronicNonFatalFailure: OptionalEvent<void, any>;
              electronicTemperatureHigh: OptionalEvent<void, any>;
              generalFault: OptionalEvent<void, any>;
              leakage: OptionalEvent<void, any>;
              motorTemperatureHigh: OptionalEvent<void, any>;
              powerMissingPhase: OptionalEvent<void, any>;
              pumpBlocked: OptionalEvent<void, any>;
              pumpMotorFatalFailure: OptionalEvent<void, any>;
              sensorFailure: OptionalEvent<void, any>;
              supplyVoltageHigh: OptionalEvent<void, any>;
              supplyVoltageLow: OptionalEvent<void, any>;
              systemPressureHigh: OptionalEvent<void, any>;
              systemPressureLow: OptionalEvent<void, any>;
              turbineOperation: OptionalEvent<void, any>;
          };
          features: {
              automatic: BitFlag;
              compensatedPressure: BitFlag;
              constantFlow: BitFlag;
              constantPressure: BitFlag;
              constantSpeed: BitFlag;
              constantTemperature: BitFlag;
              localOperation: BitFlag;
          };
          id: 512;
          name: "PumpConfigurationAndControl";
          revision: 4;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            capacity: Attribute<null | number, any>;
            controlMode: OptionalWritableAttribute<PumpConfigurationAndControl.ControlMode, any>;
            effectiveControlMode: Attribute<PumpConfigurationAndControl.ControlMode, any>;
            effectiveOperationMode: Attribute<PumpConfigurationAndControl.OperationMode, any>;
            lifetimeEnergyConsumed: OptionalWritableAttribute<null | number, any>;
            lifetimeRunningHours: OptionalWritableAttribute<null | number, any>;
            maxCompPressure: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    compensatedPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstFlow: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantFlow: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstPressure: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstSpeed: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstTemp: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxFlow: FixedAttribute<null | number, any>;
            maxPressure: FixedAttribute<null | number, any>;
            maxSpeed: FixedAttribute<null | number, any>;
            minCompPressure: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    compensatedPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstFlow: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantFlow: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstPressure: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstSpeed: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstTemp: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            operationMode: WritableAttribute<PumpConfigurationAndControl.OperationMode, any>;
            power: OptionalAttribute<null | number, any>;
            pumpStatus: OptionalAttribute<TypeFromPartialBitSchema<{
                deviceFault: BitFlag;
                localOverride: BitFlag;
                remoteFlow: BitFlag;
                remotePressure: BitFlag;
                remoteTemperature: BitFlag;
                running: BitFlag;
                speedHigh: BitFlag;
                speedLow: BitFlag;
                supplyFault: BitFlag;
            }>, any>;
            speed: OptionalAttribute<null | number, any>;
        };
        events: {
            airDetection: OptionalEvent<void, any>;
            dryRunning: OptionalEvent<void, any>;
            electronicFatalFailure: OptionalEvent<void, any>;
            electronicNonFatalFailure: OptionalEvent<void, any>;
            electronicTemperatureHigh: OptionalEvent<void, any>;
            generalFault: OptionalEvent<void, any>;
            leakage: OptionalEvent<void, any>;
            motorTemperatureHigh: OptionalEvent<void, any>;
            powerMissingPhase: OptionalEvent<void, any>;
            pumpBlocked: OptionalEvent<void, any>;
            pumpMotorFatalFailure: OptionalEvent<void, any>;
            sensorFailure: OptionalEvent<void, any>;
            supplyVoltageHigh: OptionalEvent<void, any>;
            supplyVoltageLow: OptionalEvent<void, any>;
            systemPressureHigh: OptionalEvent<void, any>;
            systemPressureLow: OptionalEvent<void, any>;
            turbineOperation: OptionalEvent<void, any>;
        };
        features: {
            automatic: BitFlag;
            compensatedPressure: BitFlag;
            constantFlow: BitFlag;
            constantPressure: BitFlag;
            constantSpeed: BitFlag;
            constantTemperature: BitFlag;
            localOperation: BitFlag;
        };
        id: 512;
        name: "PumpConfigurationAndControl";
        revision: 4;
    }>, AlterationsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              capacity: Attribute<null | number, any>;
              controlMode: OptionalWritableAttribute<PumpConfigurationAndControl.ControlMode, any>;
              effectiveControlMode: Attribute<PumpConfigurationAndControl.ControlMode, any>;
              effectiveOperationMode: Attribute<PumpConfigurationAndControl.OperationMode, any>;
              lifetimeEnergyConsumed: OptionalWritableAttribute<null | number, any>;
              lifetimeRunningHours: OptionalWritableAttribute<null | number, any>;
              maxCompPressure: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      compensatedPressure: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              maxConstFlow: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantFlow: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              maxConstPressure: FixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantPressure: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              maxConstSpeed: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantSpeed: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              maxConstTemp: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantTemperature: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              maxFlow: FixedAttribute<null | number, any>;
              maxPressure: FixedAttribute<null | number, any>;
              maxSpeed: FixedAttribute<null | number, any>;
              minCompPressure: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      compensatedPressure: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              minConstFlow: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantFlow: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              minConstPressure: FixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantPressure: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              minConstSpeed: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantSpeed: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              minConstTemp: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantTemperature: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              operationMode: WritableAttribute<PumpConfigurationAndControl.OperationMode, any>;
              power: OptionalAttribute<null | number, any>;
              pumpStatus: OptionalAttribute<TypeFromPartialBitSchema<{
                  deviceFault: BitFlag;
                  localOverride: BitFlag;
                  remoteFlow: BitFlag;
                  remotePressure: BitFlag;
                  remoteTemperature: BitFlag;
                  running: BitFlag;
                  speedHigh: BitFlag;
                  speedLow: BitFlag;
                  supplyFault: BitFlag;
              }>, any>;
              speed: OptionalAttribute<null | number, any>;
          };
          events: {
              airDetection: OptionalEvent<void, any>;
              dryRunning: OptionalEvent<void, any>;
              electronicFatalFailure: OptionalEvent<void, any>;
              electronicNonFatalFailure: OptionalEvent<void, any>;
              electronicTemperatureHigh: OptionalEvent<void, any>;
              generalFault: OptionalEvent<void, any>;
              leakage: OptionalEvent<void, any>;
              motorTemperatureHigh: OptionalEvent<void, any>;
              powerMissingPhase: OptionalEvent<void, any>;
              pumpBlocked: OptionalEvent<void, any>;
              pumpMotorFatalFailure: OptionalEvent<void, any>;
              sensorFailure: OptionalEvent<void, any>;
              supplyVoltageHigh: OptionalEvent<void, any>;
              supplyVoltageLow: OptionalEvent<void, any>;
              systemPressureHigh: OptionalEvent<void, any>;
              systemPressureLow: OptionalEvent<void, any>;
              turbineOperation: OptionalEvent<void, any>;
          };
          features: {
              automatic: BitFlag;
              compensatedPressure: BitFlag;
              constantFlow: BitFlag;
              constantPressure: BitFlag;
              constantSpeed: BitFlag;
              constantTemperature: BitFlag;
              localOperation: BitFlag;
          };
          id: 512;
          name: "PumpConfigurationAndControl";
          revision: 4;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            capacity: Attribute<null | number, any>;
            controlMode: OptionalWritableAttribute<PumpConfigurationAndControl.ControlMode, any>;
            effectiveControlMode: Attribute<PumpConfigurationAndControl.ControlMode, any>;
            effectiveOperationMode: Attribute<PumpConfigurationAndControl.OperationMode, any>;
            lifetimeEnergyConsumed: OptionalWritableAttribute<null | number, any>;
            lifetimeRunningHours: OptionalWritableAttribute<null | number, any>;
            maxCompPressure: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    compensatedPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstFlow: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantFlow: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstPressure: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstSpeed: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstTemp: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxFlow: FixedAttribute<null | number, any>;
            maxPressure: FixedAttribute<null | number, any>;
            maxSpeed: FixedAttribute<null | number, any>;
            minCompPressure: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    compensatedPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstFlow: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantFlow: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstPressure: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstSpeed: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstTemp: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            operationMode: WritableAttribute<PumpConfigurationAndControl.OperationMode, any>;
            power: OptionalAttribute<null | number, any>;
            pumpStatus: OptionalAttribute<TypeFromPartialBitSchema<{
                deviceFault: BitFlag;
                localOverride: BitFlag;
                remoteFlow: BitFlag;
                remotePressure: BitFlag;
                remoteTemperature: BitFlag;
                running: BitFlag;
                speedHigh: BitFlag;
                speedLow: BitFlag;
                supplyFault: BitFlag;
            }>, any>;
            speed: OptionalAttribute<null | number, any>;
        };
        events: {
            airDetection: OptionalEvent<void, any>;
            dryRunning: OptionalEvent<void, any>;
            electronicFatalFailure: OptionalEvent<void, any>;
            electronicNonFatalFailure: OptionalEvent<void, any>;
            electronicTemperatureHigh: OptionalEvent<void, any>;
            generalFault: OptionalEvent<void, any>;
            leakage: OptionalEvent<void, any>;
            motorTemperatureHigh: OptionalEvent<void, any>;
            powerMissingPhase: OptionalEvent<void, any>;
            pumpBlocked: OptionalEvent<void, any>;
            pumpMotorFatalFailure: OptionalEvent<void, any>;
            sensorFailure: OptionalEvent<void, any>;
            supplyVoltageHigh: OptionalEvent<void, any>;
            supplyVoltageLow: OptionalEvent<void, any>;
            systemPressureHigh: OptionalEvent<void, any>;
            systemPressureLow: OptionalEvent<void, any>;
            turbineOperation: OptionalEvent<void, any>;
        };
        features: {
            automatic: BitFlag;
            compensatedPressure: BitFlag;
            constantFlow: BitFlag;
            constantPressure: BitFlag;
            constantSpeed: BitFlag;
            constantTemperature: BitFlag;
            localOperation: BitFlag;
        };
        id: 512;
        name: "PumpConfigurationAndControl";
        revision: 4;
    }>, FlagsT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          capacity: null | number;
          controlMode?: number;
          effectiveControlMode: number;
          effectiveOperationMode: number;
          lifetimeEnergyConsumed?: null | number;
          lifetimeRunningHours?: null | number;
          maxCompPressure?: null | number;
          maxConstFlow?: null | number;
          maxConstPressure?: null | number;
          maxConstSpeed?: null | number;
          maxConstTemp?: null | number;
          maxFlow: null | number;
          maxPressure: null | number;
          maxSpeed: null | number;
          minCompPressure?: null | number;
          minConstFlow?: null | number;
          minConstPressure?: null | number;
          minConstSpeed?: null | number;
          minConstTemp?: null | number;
          operationMode: number;
          power?: null | number;
          pumpStatus?: {
              deviceFault?: boolean;
              localOverride?: boolean;
              remoteFlow?: boolean;
              remotePressure?: boolean;
              remoteTemperature?: boolean;
              running?: boolean;
              speedHigh?: boolean;
              speedLow?: boolean;
              supplyFault?: boolean;
          };
          speed?: null | number;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            capacity: Attribute<null | number, any>;
            controlMode: OptionalWritableAttribute<PumpConfigurationAndControl.ControlMode, any>;
            effectiveControlMode: Attribute<PumpConfigurationAndControl.ControlMode, any>;
            effectiveOperationMode: Attribute<PumpConfigurationAndControl.OperationMode, any>;
            lifetimeEnergyConsumed: OptionalWritableAttribute<null | number, any>;
            lifetimeRunningHours: OptionalWritableAttribute<null | number, any>;
            maxCompPressure: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    compensatedPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstFlow: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantFlow: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstPressure: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstSpeed: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstTemp: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxFlow: FixedAttribute<null | number, any>;
            maxPressure: FixedAttribute<null | number, any>;
            maxSpeed: FixedAttribute<null | number, any>;
            minCompPressure: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    compensatedPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstFlow: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantFlow: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstPressure: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstSpeed: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstTemp: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            operationMode: WritableAttribute<PumpConfigurationAndControl.OperationMode, any>;
            power: OptionalAttribute<null | number, any>;
            pumpStatus: OptionalAttribute<TypeFromPartialBitSchema<{
                deviceFault: BitFlag;
                localOverride: BitFlag;
                remoteFlow: BitFlag;
                remotePressure: BitFlag;
                remoteTemperature: BitFlag;
                running: BitFlag;
                speedHigh: BitFlag;
                speedLow: BitFlag;
                supplyFault: BitFlag;
            }>, any>;
            speed: OptionalAttribute<null | number, any>;
        };
        events: {
            airDetection: OptionalEvent<void, any>;
            dryRunning: OptionalEvent<void, any>;
            electronicFatalFailure: OptionalEvent<void, any>;
            electronicNonFatalFailure: OptionalEvent<void, any>;
            electronicTemperatureHigh: OptionalEvent<void, any>;
            generalFault: OptionalEvent<void, any>;
            leakage: OptionalEvent<void, any>;
            motorTemperatureHigh: OptionalEvent<void, any>;
            powerMissingPhase: OptionalEvent<void, any>;
            pumpBlocked: OptionalEvent<void, any>;
            pumpMotorFatalFailure: OptionalEvent<void, any>;
            sensorFailure: OptionalEvent<void, any>;
            supplyVoltageHigh: OptionalEvent<void, any>;
            supplyVoltageLow: OptionalEvent<void, any>;
            systemPressureHigh: OptionalEvent<void, any>;
            systemPressureLow: OptionalEvent<void, any>;
            turbineOperation: OptionalEvent<void, any>;
        };
        features: {
            automatic: BitFlag;
            compensatedPressure: BitFlag;
            constantFlow: BitFlag;
            constantPressure: BitFlag;
            constantSpeed: BitFlag;
            constantTemperature: BitFlag;
            localOperation: BitFlag;
        };
        id: 512;
        name: "PumpConfigurationAndControl";
        revision: 4;
    }>, ValuesT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              capacity: Attribute<null | number, any>;
              controlMode: OptionalWritableAttribute<PumpConfigurationAndControl.ControlMode, any>;
              effectiveControlMode: Attribute<PumpConfigurationAndControl.ControlMode, any>;
              effectiveOperationMode: Attribute<PumpConfigurationAndControl.OperationMode, any>;
              lifetimeEnergyConsumed: OptionalWritableAttribute<null | number, any>;
              lifetimeRunningHours: OptionalWritableAttribute<null | number, any>;
              maxCompPressure: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      compensatedPressure: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              maxConstFlow: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantFlow: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              maxConstPressure: FixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantPressure: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              maxConstSpeed: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantSpeed: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              maxConstTemp: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantTemperature: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              maxFlow: FixedAttribute<null | number, any>;
              maxPressure: FixedAttribute<null | number, any>;
              maxSpeed: FixedAttribute<null | number, any>;
              minCompPressure: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      compensatedPressure: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              minConstFlow: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantFlow: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              minConstPressure: FixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantPressure: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              minConstSpeed: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantSpeed: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              minConstTemp: OptionalFixedAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      constantTemperature: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      automatic: boolean;
                  }];
              };
              operationMode: WritableAttribute<PumpConfigurationAndControl.OperationMode, any>;
              power: OptionalAttribute<null | number, any>;
              pumpStatus: OptionalAttribute<TypeFromPartialBitSchema<{
                  deviceFault: BitFlag;
                  localOverride: BitFlag;
                  remoteFlow: BitFlag;
                  remotePressure: BitFlag;
                  remoteTemperature: BitFlag;
                  running: BitFlag;
                  speedHigh: BitFlag;
                  speedLow: BitFlag;
                  supplyFault: BitFlag;
              }>, any>;
              speed: OptionalAttribute<null | number, any>;
          };
          events: {
              airDetection: OptionalEvent<void, any>;
              dryRunning: OptionalEvent<void, any>;
              electronicFatalFailure: OptionalEvent<void, any>;
              electronicNonFatalFailure: OptionalEvent<void, any>;
              electronicTemperatureHigh: OptionalEvent<void, any>;
              generalFault: OptionalEvent<void, any>;
              leakage: OptionalEvent<void, any>;
              motorTemperatureHigh: OptionalEvent<void, any>;
              powerMissingPhase: OptionalEvent<void, any>;
              pumpBlocked: OptionalEvent<void, any>;
              pumpMotorFatalFailure: OptionalEvent<void, any>;
              sensorFailure: OptionalEvent<void, any>;
              supplyVoltageHigh: OptionalEvent<void, any>;
              supplyVoltageLow: OptionalEvent<void, any>;
              systemPressureHigh: OptionalEvent<void, any>;
              systemPressureLow: OptionalEvent<void, any>;
              turbineOperation: OptionalEvent<void, any>;
          };
          features: {
              automatic: BitFlag;
              compensatedPressure: BitFlag;
              constantFlow: BitFlag;
              constantPressure: BitFlag;
              constantSpeed: BitFlag;
              constantTemperature: BitFlag;
              localOperation: BitFlag;
          };
          id: 512;
          name: "PumpConfigurationAndControl";
          revision: 4;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            capacity: Attribute<null | number, any>;
            controlMode: OptionalWritableAttribute<PumpConfigurationAndControl.ControlMode, any>;
            effectiveControlMode: Attribute<PumpConfigurationAndControl.ControlMode, any>;
            effectiveOperationMode: Attribute<PumpConfigurationAndControl.OperationMode, any>;
            lifetimeEnergyConsumed: OptionalWritableAttribute<null | number, any>;
            lifetimeRunningHours: OptionalWritableAttribute<null | number, any>;
            maxCompPressure: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    compensatedPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstFlow: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantFlow: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstPressure: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstSpeed: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxConstTemp: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            maxFlow: FixedAttribute<null | number, any>;
            maxPressure: FixedAttribute<null | number, any>;
            maxSpeed: FixedAttribute<null | number, any>;
            minCompPressure: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    compensatedPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstFlow: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantFlow: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstPressure: FixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantPressure: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstSpeed: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantSpeed: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            minConstTemp: OptionalFixedAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    constantTemperature: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    automatic: boolean;
                }];
            };
            operationMode: WritableAttribute<PumpConfigurationAndControl.OperationMode, any>;
            power: OptionalAttribute<null | number, any>;
            pumpStatus: OptionalAttribute<TypeFromPartialBitSchema<{
                deviceFault: BitFlag;
                localOverride: BitFlag;
                remoteFlow: BitFlag;
                remotePressure: BitFlag;
                remoteTemperature: BitFlag;
                running: BitFlag;
                speedHigh: BitFlag;
                speedLow: BitFlag;
                supplyFault: BitFlag;
            }>, any>;
            speed: OptionalAttribute<null | number, any>;
        };
        events: {
            airDetection: OptionalEvent<void, any>;
            dryRunning: OptionalEvent<void, any>;
            electronicFatalFailure: OptionalEvent<void, any>;
            electronicNonFatalFailure: OptionalEvent<void, any>;
            electronicTemperatureHigh: OptionalEvent<void, any>;
            generalFault: OptionalEvent<void, any>;
            leakage: OptionalEvent<void, any>;
            motorTemperatureHigh: OptionalEvent<void, any>;
            powerMissingPhase: OptionalEvent<void, any>;
            pumpBlocked: OptionalEvent<void, any>;
            pumpMotorFatalFailure: OptionalEvent<void, any>;
            sensorFailure: OptionalEvent<void, any>;
            supplyVoltageHigh: OptionalEvent<void, any>;
            supplyVoltageLow: OptionalEvent<void, any>;
            systemPressureHigh: OptionalEvent<void, any>;
            systemPressureLow: OptionalEvent<void, any>;
            turbineOperation: OptionalEvent<void, any>;
        };
        features: {
            automatic: BitFlag;
            compensatedPressure: BitFlag;
            constantFlow: BitFlag;
            constantPressure: BitFlag;
            constantSpeed: BitFlag;
            constantTemperature: BitFlag;
            localOperation: BitFlag;
        };
        id: 512;
        name: "PumpConfigurationAndControl";
        revision: 4;
    }>, SelectionT>