Variable clientConst

client: {
    mandatory: {
        WindowCovering: Type<Of<{
            attributes: {
                configStatus: Attribute<TypeFromPartialBitSchema<{
                    liftEncoderControlled: BitFlag;
                    liftMovementReversed: BitFlag;
                    liftPositionAware: BitFlag;
                    onlineReserved: BitFlag;
                    operational: BitFlag;
                    tiltEncoderControlled: BitFlag;
                    tiltPositionAware: BitFlag;
                }>, any>;
                endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
                mode: WritableAttribute<TypeFromPartialBitSchema<{
                    calibrationMode: BitFlag;
                    ledFeedback: BitFlag;
                    maintenanceMode: BitFlag;
                    motorDirectionReversed: BitFlag;
                }>, any>;
                operationalStatus: Attribute<TypeFromPartialBitSchema<{
                    global: BitFieldEnum<WindowCovering.MovementStatus>;
                    lift: BitFieldEnum<WindowCovering.MovementStatus>;
                    tilt: BitFieldEnum<WindowCovering.MovementStatus>;
                }>, any>;
                safetyStatus: OptionalAttribute<TypeFromPartialBitSchema<{
                    failedCommunication: BitFlag;
                    hardwareFailure: BitFlag;
                    manualOperation: BitFlag;
                    motorJammed: BitFlag;
                    obstacleDetected: BitFlag;
                    positionFailure: BitFlag;
                    power: BitFlag;
                    protection: BitFlag;
                    remoteLockout: BitFlag;
                    stopInput: BitFlag;
                    tamperDetection: BitFlag;
                    thermalProtection: BitFlag;
                }>, any>;
                type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
            };
            commands: {
                downOrClose: Command<void, void, any>;
                stopMotion: Command<void, void, any>;
                upOrOpen: Command<void, void, any>;
            };
            extensions: readonly [{
                component: {
                    attributes: {
                        currentPositionLift: OptionalAttribute<(...) | (...), any>;
                        installedClosedLimitLift: Attribute<number, any>;
                        installedOpenLimitLift: Attribute<number, any>;
                        physicalClosedLimitLift: OptionalFixedAttribute<number, any>;
                    };
                };
                flags: {
                    absolutePosition: true;
                    lift: true;
                    positionAwareLift: true;
                };
            }, {
                component: {
                    attributes: {
                        currentPositionTilt: OptionalAttribute<(...) | (...), any>;
                        installedClosedLimitTilt: Attribute<number, any>;
                        installedOpenLimitTilt: Attribute<number, any>;
                        physicalClosedLimitTilt: OptionalFixedAttribute<number, any>;
                    };
                };
                flags: {
                    absolutePosition: true;
                    positionAwareTilt: true;
                    tilt: true;
                };
            }, {
                component: {
                    attributes: {
                        numberOfActuationsLift: OptionalAttribute<number, any>;
                    };
                    commands: {
                        goToLiftPercentage: OptionalCommand<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    lift: true;
                };
            }, {
                component: {
                    attributes: {
                        numberOfActuationsTilt: OptionalAttribute<number, any>;
                    };
                    commands: {
                        goToTiltPercentage: OptionalCommand<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    tilt: true;
                };
            }, {
                component: {
                    attributes: {
                        currentPositionLiftPercent100ths: Attribute<(...) | (...), any>;
                        currentPositionLiftPercentage: OptionalAttribute<(...) | (...), any>;
                        targetPositionLiftPercent100ths: Attribute<(...) | (...), any>;
                    };
                    commands: {
                        goToLiftPercentage: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    lift: true;
                    positionAwareLift: true;
                };
            }, {
                component: {
                    attributes: {
                        currentPositionTiltPercent100ths: Attribute<(...) | (...), any>;
                        currentPositionTiltPercentage: OptionalAttribute<(...) | (...), any>;
                        targetPositionTiltPercent100ths: Attribute<(...) | (...), any>;
                    };
                    commands: {
                        goToTiltPercentage: Command<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    positionAwareTilt: true;
                    tilt: true;
                };
            }, {
                component: {
                    commands: {
                        goToLiftValue: OptionalCommand<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    absolutePosition: true;
                    lift: true;
                };
            }, {
                component: {
                    commands: {
                        goToTiltValue: OptionalCommand<TypeFromFields<(...)>, void, any>;
                    };
                };
                flags: {
                    absolutePosition: true;
                    tilt: true;
                };
            }, {
                component: false;
                flags: {
                    lift: false;
                    positionAwareLift: true;
                };
            }, {
                component: false;
                flags: {
                    positionAwareTilt: true;
                    tilt: false;
                };
            }, {
                component: false;
                flags: {
                    lift: false;
                    tilt: false;
                };
            }];
            features: {
                absolutePosition: BitFlag;
                lift: BitFlag;
                positionAwareLift: BitFlag;
                positionAwareTilt: BitFlag;
                tilt: BitFlag;
            };
            id: 258;
            name: "WindowCovering";
            revision: 5;
        }>, Type<Of<{
            attributes: {};
            commands: {};
            events: {};
            id: 0;
            name: "Unknown";
            revision: 0;
        }>, typeof ClusterBehavior, WindowCoveringInterface>, WindowCoveringInterface>;
    };
    optional: {
        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>;
        ScenesManagement: Type<ScenesManagement.Cluster, Type<Of<{
            attributes: {};
            commands: {};
            events: {};
            id: 0;
            name: "Unknown";
            revision: 0;
        }>, typeof ClusterBehavior, ScenesManagementInterface>, ScenesManagementInterface>;
    };
} = ...

A definition for each client cluster supported by the endpoint per the Matter specification.

Settings

Member Visibility