Variable WindowCoveringBehaviorConst

WindowCoveringBehavior: 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<null | number, any>;
                installedClosedLimitLift: Attribute<number, any>;
                installedOpenLimitLift: Attribute<number, any>;
                physicalClosedLimitLift: OptionalFixedAttribute<number, any>;
            };
        };
        flags: {
            absolutePosition: true;
            lift: true;
            positionAwareLift: true;
        };
    }, {
        component: {
            attributes: {
                currentPositionTilt: OptionalAttribute<null | number, 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<{
                    liftPercent100thsValue: FieldType<(...)>;
                }>, void, any>;
            };
        };
        flags: {
            lift: true;
        };
    }, {
        component: {
            attributes: {
                numberOfActuationsTilt: OptionalAttribute<number, any>;
            };
            commands: {
                goToTiltPercentage: OptionalCommand<TypeFromFields<{
                    tiltPercent100thsValue: FieldType<(...)>;
                }>, void, any>;
            };
        };
        flags: {
            tilt: true;
        };
    }, {
        component: {
            attributes: {
                currentPositionLiftPercent100ths: Attribute<null | number, any>;
                currentPositionLiftPercentage: OptionalAttribute<null | number, any>;
                targetPositionLiftPercent100ths: Attribute<null | number, any>;
            };
            commands: {
                goToLiftPercentage: Command<TypeFromFields<{
                    liftPercent100thsValue: FieldType<(...)>;
                }>, void, any>;
            };
        };
        flags: {
            lift: true;
            positionAwareLift: true;
        };
    }, {
        component: {
            attributes: {
                currentPositionTiltPercent100ths: Attribute<null | number, any>;
                currentPositionTiltPercentage: OptionalAttribute<null | number, any>;
                targetPositionTiltPercent100ths: Attribute<null | number, any>;
            };
            commands: {
                goToTiltPercentage: Command<TypeFromFields<{
                    tiltPercent100thsValue: FieldType<(...)>;
                }>, void, any>;
            };
        };
        flags: {
            positionAwareTilt: true;
            tilt: true;
        };
    }, {
        component: {
            commands: {
                goToLiftValue: OptionalCommand<TypeFromFields<{
                    liftValue: FieldType<(...)>;
                }>, void, any>;
            };
        };
        flags: {
            absolutePosition: true;
            lift: true;
        };
    }, {
        component: {
            commands: {
                goToTiltValue: OptionalCommand<TypeFromFields<{
                    tiltValue: FieldType<(...)>;
                }>, 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> = ...

WindowCoveringBehavior is the base class for objects that support interaction with WindowCovering.Cluster.

WindowCovering.Cluster requires you to enable one or more optional features. You can do so using WindowCoveringBehavior.with.

Settings

Member Visibility