Variable clientConst

client: {
    mandatory: {
        Binding: Type<Binding.Cluster, typeof ClusterBehavior, {
            components: never[];
        }>;
        OnOff: Type<OnOff.Cluster, Type<Of<{
            attributes: {};
            commands: {};
            events: {};
            id: 0;
            name: "Unknown";
            revision: 0;
        }>, typeof ClusterBehavior, OnOffInterface>, OnOffInterface>;
        PumpConfigurationAndControl: Type<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>;
                maxFlow: FixedAttribute<null | number, any>;
                maxPressure: FixedAttribute<null | number, any>;
                maxSpeed: FixedAttribute<null | number, any>;
                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>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        maxConstPressure: FixedAttribute<(...) | (...), any>;
                        minConstPressure: FixedAttribute<(...) | (...), any>;
                    };
                };
                flags: {
                    constantPressure: true;
                };
            }, {
                component: {
                    attributes: {
                        maxCompPressure: OptionalFixedAttribute<(...) | (...), any>;
                        maxConstFlow: OptionalFixedAttribute<(...) | (...), any>;
                        maxConstPressure: OptionalFixedAttribute<(...) | (...), any>;
                        maxConstSpeed: OptionalFixedAttribute<(...) | (...), any>;
                        maxConstTemp: OptionalFixedAttribute<(...) | (...), any>;
                        minCompPressure: OptionalFixedAttribute<(...) | (...), any>;
                        minConstFlow: OptionalFixedAttribute<(...) | (...), any>;
                        minConstPressure: OptionalFixedAttribute<(...) | (...), any>;
                        minConstSpeed: OptionalFixedAttribute<(...) | (...), any>;
                        minConstTemp: OptionalFixedAttribute<(...) | (...), any>;
                    };
                };
                flags: {
                    automatic: true;
                };
            }, {
                component: {
                    attributes: {
                        maxCompPressure: FixedAttribute<(...) | (...), any>;
                        minCompPressure: FixedAttribute<(...) | (...), any>;
                    };
                };
                flags: {
                    compensatedPressure: true;
                };
            }, {
                component: {
                    attributes: {
                        maxConstSpeed: FixedAttribute<(...) | (...), any>;
                        minConstSpeed: FixedAttribute<(...) | (...), any>;
                    };
                };
                flags: {
                    constantSpeed: true;
                };
            }, {
                component: {
                    attributes: {
                        maxConstFlow: FixedAttribute<(...) | (...), any>;
                        minConstFlow: FixedAttribute<(...) | (...), any>;
                    };
                };
                flags: {
                    constantFlow: true;
                };
            }, {
                component: {
                    attributes: {
                        maxConstTemp: FixedAttribute<(...) | (...), any>;
                        minConstTemp: FixedAttribute<(...) | (...), any>;
                    };
                };
                flags: {
                    constantTemperature: true;
                };
            }, {
                component: false;
                flags: {
                    compensatedPressure: false;
                    constantFlow: false;
                    constantPressure: false;
                    constantSpeed: false;
                    constantTemperature: false;
                };
            }];
            features: {
                automatic: BitFlag;
                compensatedPressure: BitFlag;
                constantFlow: BitFlag;
                constantPressure: BitFlag;
                constantSpeed: BitFlag;
                constantTemperature: BitFlag;
                localOperation: BitFlag;
            };
            id: 512;
            name: "PumpConfigurationAndControl";
            revision: 4;
        }>, typeof ClusterBehavior, {
            components: never[];
        }>;
    };
    optional: {
        FlowMeasurement: Type<FlowMeasurement.Cluster, typeof ClusterBehavior, {
            components: never[];
        }>;
        Groups: Type<Groups.Cluster, Type<Of<{
            attributes: {};
            commands: {};
            events: {};
            id: 0;
            name: "Unknown";
            revision: 0;
        }>, typeof ClusterBehavior, GroupsInterface>, GroupsInterface>;
        Identify: Type<Identify.Cluster, Type<Of<{
            attributes: {};
            commands: {};
            events: {};
            id: 0;
            name: "Unknown";
            revision: 0;
        }>, typeof ClusterBehavior, IdentifyInterface>, IdentifyInterface>;
        LevelControl: Type<LevelControl.Cluster, Type<Of<{
            attributes: {};
            commands: {};
            events: {};
            id: 0;
            name: "Unknown";
            revision: 0;
        }>, typeof ClusterBehavior, LevelControlInterface>, LevelControlInterface>;
        PressureMeasurement: Type<PressureMeasurement.Cluster, typeof ClusterBehavior, {
            components: never[];
        }>;
        ScenesManagement: Type<ScenesManagement.Cluster, Type<Of<{
            attributes: {};
            commands: {};
            events: {};
            id: 0;
            name: "Unknown";
            revision: 0;
        }>, typeof ClusterBehavior, ScenesManagementInterface>, ScenesManagementInterface>;
        TemperatureMeasurement: Type<TemperatureMeasurement.Cluster, typeof ClusterBehavior, {
            components: never[];
        }>;
    };
} = ...