Interface Complete

This cluster supports all WindowCovering 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<{
        configStatus: Attribute<TypeFromPartialBitSchema<{
            liftEncoderControlled: BitFlag;
            liftMovementReversed: BitFlag;
            liftPositionAware: BitFlag;
            onlineReserved: BitFlag;
            operational: BitFlag;
            tiltEncoderControlled: BitFlag;
            tiltPositionAware: BitFlag;
        }>, any>;
        currentPositionLift: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                absolutePosition: boolean;
                lift: boolean;
                positionAwareLift: boolean;
            }];
        };
        currentPositionLiftPercent100ths: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                lift: boolean;
                positionAwareLift: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        currentPositionLiftPercentage: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                lift: boolean;
                positionAwareLift: boolean;
            }];
        };
        currentPositionTilt: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                absolutePosition: boolean;
                positionAwareTilt: boolean;
                tilt: boolean;
            }];
        };
        currentPositionTiltPercent100ths: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                positionAwareTilt: boolean;
                tilt: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        currentPositionTiltPercentage: OptionalAttribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                positionAwareTilt: boolean;
                tilt: boolean;
            }];
        };
        endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
        installedClosedLimitLift: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                absolutePosition: boolean;
                lift: boolean;
                positionAwareLift: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        installedClosedLimitTilt: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                absolutePosition: boolean;
                positionAwareTilt: boolean;
                tilt: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        installedOpenLimitLift: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                absolutePosition: boolean;
                lift: boolean;
                positionAwareLift: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        installedOpenLimitTilt: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                absolutePosition: boolean;
                positionAwareTilt: boolean;
                tilt: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        mode: WritableAttribute<TypeFromPartialBitSchema<{
            calibrationMode: BitFlag;
            ledFeedback: BitFlag;
            maintenanceMode: BitFlag;
            motorDirectionReversed: BitFlag;
        }>, any>;
        numberOfActuationsLift: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                lift: boolean;
            }];
        };
        numberOfActuationsTilt: OptionalAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                tilt: boolean;
            }];
        };
        operationalStatus: Attribute<TypeFromPartialBitSchema<{
            global: BitFieldEnum<WindowCovering.MovementStatus>;
            lift: BitFieldEnum<WindowCovering.MovementStatus>;
            tilt: BitFieldEnum<WindowCovering.MovementStatus>;
        }>, any>;
        physicalClosedLimitLift: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                absolutePosition: boolean;
                lift: boolean;
                positionAwareLift: boolean;
            }];
        };
        physicalClosedLimitTilt: OptionalFixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                absolutePosition: boolean;
                positionAwareTilt: boolean;
                tilt: boolean;
            }];
        };
        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>;
        targetPositionLiftPercent100ths: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                lift: boolean;
                positionAwareLift: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        targetPositionTiltPercent100ths: Attribute<null | number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                positionAwareTilt: boolean;
                tilt: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
    }, GlobalAttributes<{
        absolutePosition: BitFlag;
        lift: BitFlag;
        positionAwareLift: BitFlag;
        positionAwareTilt: BitFlag;
        tilt: BitFlag;
    }>>;
    base: undefined;
    commands: {
        downOrClose: Command<void, void, any>;
        goToLiftPercentage: OptionalCommand<TypeFromFields<{
            liftPercent100thsValue: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                lift: boolean;
                positionAwareLift: boolean;
            }];
            optional: true;
            optionalIf: [] | [{
                lift: boolean;
            }];
        };
        goToLiftValue: OptionalCommand<TypeFromFields<{
            liftValue: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                absolutePosition: boolean;
                lift: boolean;
            }];
        };
        goToTiltPercentage: OptionalCommand<TypeFromFields<{
            tiltPercent100thsValue: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                positionAwareTilt: boolean;
                tilt: boolean;
            }];
            optional: true;
            optionalIf: [] | [{
                tilt: boolean;
            }];
        };
        goToTiltValue: OptionalCommand<TypeFromFields<{
            tiltValue: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                absolutePosition: boolean;
                tilt: boolean;
            }];
        };
        stopMotion: Command<void, void, any>;
        upOrOpen: Command<void, void, any>;
    };
    events: {};
    extensions: undefined;
    features: {
        absolutePosition: BitFlag;
        lift: BitFlag;
        positionAwareLift: BitFlag;
        positionAwareTilt: BitFlag;
        tilt: BitFlag;
    };
    id: Branded<258, "ClusterId">;
    name: "WindowCovering";
    revision: 5;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            configStatus: Attribute<TypeFromPartialBitSchema<{
                liftEncoderControlled: BitFlag;
                liftMovementReversed: BitFlag;
                liftPositionAware: BitFlag;
                onlineReserved: BitFlag;
                operational: BitFlag;
                tiltEncoderControlled: BitFlag;
                tiltPositionAware: BitFlag;
            }>, any>;
            currentPositionLift: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionLiftPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionTilt: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            currentPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionTiltPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
            installedClosedLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedClosedLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            mode: WritableAttribute<TypeFromPartialBitSchema<{
                calibrationMode: BitFlag;
                ledFeedback: BitFlag;
                maintenanceMode: BitFlag;
                motorDirectionReversed: BitFlag;
            }>, any>;
            numberOfActuationsLift: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            numberOfActuationsTilt: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            operationalStatus: Attribute<TypeFromPartialBitSchema<{
                global: BitFieldEnum<WindowCovering.MovementStatus>;
                lift: BitFieldEnum<WindowCovering.MovementStatus>;
                tilt: BitFieldEnum<WindowCovering.MovementStatus>;
            }>, any>;
            physicalClosedLimitLift: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            physicalClosedLimitTilt: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            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>;
            targetPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            targetPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
        };
        commands: {
            downOrClose: Command<void, void, any>;
            goToLiftPercentage: OptionalCommand<TypeFromFields<{
                liftPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            goToLiftValue: OptionalCommand<TypeFromFields<{
                liftValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                }];
            };
            goToTiltPercentage: OptionalCommand<TypeFromFields<{
                tiltPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            goToTiltValue: OptionalCommand<TypeFromFields<{
                tiltValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    tilt: boolean;
                }];
            };
            stopMotion: Command<void, void, any>;
            upOrOpen: Command<void, void, any>;
        };
        features: {
            absolutePosition: BitFlag;
            lift: BitFlag;
            positionAwareLift: BitFlag;
            positionAwareTilt: BitFlag;
            tilt: BitFlag;
        };
        id: 258;
        name: "WindowCovering";
        revision: 5;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            configStatus: Attribute<TypeFromPartialBitSchema<{
                liftEncoderControlled: BitFlag;
                liftMovementReversed: BitFlag;
                liftPositionAware: BitFlag;
                onlineReserved: BitFlag;
                operational: BitFlag;
                tiltEncoderControlled: BitFlag;
                tiltPositionAware: BitFlag;
            }>, any>;
            currentPositionLift: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionLiftPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionTilt: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            currentPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionTiltPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
            installedClosedLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedClosedLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            mode: WritableAttribute<TypeFromPartialBitSchema<{
                calibrationMode: BitFlag;
                ledFeedback: BitFlag;
                maintenanceMode: BitFlag;
                motorDirectionReversed: BitFlag;
            }>, any>;
            numberOfActuationsLift: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            numberOfActuationsTilt: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            operationalStatus: Attribute<TypeFromPartialBitSchema<{
                global: BitFieldEnum<WindowCovering.MovementStatus>;
                lift: BitFieldEnum<WindowCovering.MovementStatus>;
                tilt: BitFieldEnum<WindowCovering.MovementStatus>;
            }>, any>;
            physicalClosedLimitLift: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            physicalClosedLimitTilt: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            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>;
            targetPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            targetPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
        };
        commands: {
            downOrClose: Command<void, void, any>;
            goToLiftPercentage: OptionalCommand<TypeFromFields<{
                liftPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            goToLiftValue: OptionalCommand<TypeFromFields<{
                liftValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                }];
            };
            goToTiltPercentage: OptionalCommand<TypeFromFields<{
                tiltPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            goToTiltValue: OptionalCommand<TypeFromFields<{
                tiltValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    tilt: boolean;
                }];
            };
            stopMotion: Command<void, void, any>;
            upOrOpen: Command<void, void, any>;
        };
        features: {
            absolutePosition: BitFlag;
            lift: BitFlag;
            positionAwareLift: BitFlag;
            positionAwareTilt: BitFlag;
            tilt: BitFlag;
        };
        id: 258;
        name: "WindowCovering";
        revision: 5;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            configStatus: Attribute<TypeFromPartialBitSchema<{
                liftEncoderControlled: BitFlag;
                liftMovementReversed: BitFlag;
                liftPositionAware: BitFlag;
                onlineReserved: BitFlag;
                operational: BitFlag;
                tiltEncoderControlled: BitFlag;
                tiltPositionAware: BitFlag;
            }>, any>;
            currentPositionLift: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionLiftPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionTilt: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            currentPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionTiltPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
            installedClosedLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedClosedLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            mode: WritableAttribute<TypeFromPartialBitSchema<{
                calibrationMode: BitFlag;
                ledFeedback: BitFlag;
                maintenanceMode: BitFlag;
                motorDirectionReversed: BitFlag;
            }>, any>;
            numberOfActuationsLift: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            numberOfActuationsTilt: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            operationalStatus: Attribute<TypeFromPartialBitSchema<{
                global: BitFieldEnum<WindowCovering.MovementStatus>;
                lift: BitFieldEnum<WindowCovering.MovementStatus>;
                tilt: BitFieldEnum<WindowCovering.MovementStatus>;
            }>, any>;
            physicalClosedLimitLift: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            physicalClosedLimitTilt: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            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>;
            targetPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            targetPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
        };
        commands: {
            downOrClose: Command<void, void, any>;
            goToLiftPercentage: OptionalCommand<TypeFromFields<{
                liftPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            goToLiftValue: OptionalCommand<TypeFromFields<{
                liftValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                }];
            };
            goToTiltPercentage: OptionalCommand<TypeFromFields<{
                tiltPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            goToTiltValue: OptionalCommand<TypeFromFields<{
                tiltValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    tilt: boolean;
                }];
            };
            stopMotion: Command<void, void, any>;
            upOrOpen: Command<void, void, any>;
        };
        features: {
            absolutePosition: BitFlag;
            lift: BitFlag;
            positionAwareLift: BitFlag;
            positionAwareTilt: BitFlag;
            tilt: BitFlag;
        };
        id: 258;
        name: "WindowCovering";
        revision: 5;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            configStatus: Attribute<TypeFromPartialBitSchema<{
                liftEncoderControlled: BitFlag;
                liftMovementReversed: BitFlag;
                liftPositionAware: BitFlag;
                onlineReserved: BitFlag;
                operational: BitFlag;
                tiltEncoderControlled: BitFlag;
                tiltPositionAware: BitFlag;
            }>, any>;
            currentPositionLift: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionLiftPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionTilt: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            currentPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionTiltPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
            installedClosedLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedClosedLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            mode: WritableAttribute<TypeFromPartialBitSchema<{
                calibrationMode: BitFlag;
                ledFeedback: BitFlag;
                maintenanceMode: BitFlag;
                motorDirectionReversed: BitFlag;
            }>, any>;
            numberOfActuationsLift: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            numberOfActuationsTilt: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            operationalStatus: Attribute<TypeFromPartialBitSchema<{
                global: BitFieldEnum<WindowCovering.MovementStatus>;
                lift: BitFieldEnum<WindowCovering.MovementStatus>;
                tilt: BitFieldEnum<WindowCovering.MovementStatus>;
            }>, any>;
            physicalClosedLimitLift: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            physicalClosedLimitTilt: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            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>;
            targetPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            targetPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
        };
        commands: {
            downOrClose: Command<void, void, any>;
            goToLiftPercentage: OptionalCommand<TypeFromFields<{
                liftPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            goToLiftValue: OptionalCommand<TypeFromFields<{
                liftValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                }];
            };
            goToTiltPercentage: OptionalCommand<TypeFromFields<{
                tiltPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            goToTiltValue: OptionalCommand<TypeFromFields<{
                tiltValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    tilt: boolean;
                }];
            };
            stopMotion: Command<void, void, any>;
            upOrOpen: Command<void, void, any>;
        };
        features: {
            absolutePosition: BitFlag;
            lift: BitFlag;
            positionAwareLift: BitFlag;
            positionAwareTilt: BitFlag;
            tilt: BitFlag;
        };
        id: 258;
        name: "WindowCovering";
        revision: 5;
    }>, SelectionT>;
}

Hierarchy (view full)

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: Merge<{
    configStatus: Attribute<TypeFromPartialBitSchema<{
        liftEncoderControlled: BitFlag;
        liftMovementReversed: BitFlag;
        liftPositionAware: BitFlag;
        onlineReserved: BitFlag;
        operational: BitFlag;
        tiltEncoderControlled: BitFlag;
        tiltPositionAware: BitFlag;
    }>, any>;
    currentPositionLift: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            absolutePosition: boolean;
            lift: boolean;
            positionAwareLift: boolean;
        }];
    };
    currentPositionLiftPercent100ths: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            lift: boolean;
            positionAwareLift: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    currentPositionLiftPercentage: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            lift: boolean;
            positionAwareLift: boolean;
        }];
    };
    currentPositionTilt: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            absolutePosition: boolean;
            positionAwareTilt: boolean;
            tilt: boolean;
        }];
    };
    currentPositionTiltPercent100ths: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            positionAwareTilt: boolean;
            tilt: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    currentPositionTiltPercentage: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            positionAwareTilt: boolean;
            tilt: boolean;
        }];
    };
    endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
    installedClosedLimitLift: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            absolutePosition: boolean;
            lift: boolean;
            positionAwareLift: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    installedClosedLimitTilt: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            absolutePosition: boolean;
            positionAwareTilt: boolean;
            tilt: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    installedOpenLimitLift: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            absolutePosition: boolean;
            lift: boolean;
            positionAwareLift: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    installedOpenLimitTilt: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            absolutePosition: boolean;
            positionAwareTilt: boolean;
            tilt: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    mode: WritableAttribute<TypeFromPartialBitSchema<{
        calibrationMode: BitFlag;
        ledFeedback: BitFlag;
        maintenanceMode: BitFlag;
        motorDirectionReversed: BitFlag;
    }>, any>;
    numberOfActuationsLift: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            lift: boolean;
        }];
    };
    numberOfActuationsTilt: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            tilt: boolean;
        }];
    };
    operationalStatus: Attribute<TypeFromPartialBitSchema<{
        global: BitFieldEnum<WindowCovering.MovementStatus>;
        lift: BitFieldEnum<WindowCovering.MovementStatus>;
        tilt: BitFieldEnum<WindowCovering.MovementStatus>;
    }>, any>;
    physicalClosedLimitLift: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            absolutePosition: boolean;
            lift: boolean;
            positionAwareLift: boolean;
        }];
    };
    physicalClosedLimitTilt: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            absolutePosition: boolean;
            positionAwareTilt: boolean;
            tilt: boolean;
        }];
    };
    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>;
    targetPositionLiftPercent100ths: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            lift: boolean;
            positionAwareLift: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    targetPositionTiltPercent100ths: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            positionAwareTilt: boolean;
            tilt: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
}, GlobalAttributes<{
    absolutePosition: BitFlag;
    lift: BitFlag;
    positionAwareLift: BitFlag;
    positionAwareTilt: BitFlag;
    tilt: BitFlag;
}>>

Type declaration

  • ReadonlyconfigStatus: Attribute<TypeFromPartialBitSchema<{
        liftEncoderControlled: BitFlag;
        liftMovementReversed: BitFlag;
        liftPositionAware: BitFlag;
        onlineReserved: BitFlag;
        operational: BitFlag;
        tiltEncoderControlled: BitFlag;
        tiltPositionAware: BitFlag;
    }>, any>

    This attribute specifies the configuration and status information of the window covering.

    To change settings, devices shall write to the Mode attribute. The behavior causing the setting or clearing of each bit is vendor specific.

    See

    MatterSpecification.v13.Cluster § 5.3.6.9

  • ReadonlycurrentPositionLift: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            absolutePosition: boolean;
            lift: boolean;
            positionAwareLift: boolean;
        }];
    }
  • ReadonlycurrentPositionLiftPercent100ths: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            lift: boolean;
            positionAwareLift: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlycurrentPositionLiftPercentage: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            lift: boolean;
            positionAwareLift: boolean;
        }];
    }
  • ReadonlycurrentPositionTilt: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            absolutePosition: boolean;
            positionAwareTilt: boolean;
            tilt: boolean;
        }];
    }
  • ReadonlycurrentPositionTiltPercent100ths: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            positionAwareTilt: boolean;
            tilt: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlycurrentPositionTiltPercentage: OptionalAttribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            positionAwareTilt: boolean;
            tilt: boolean;
        }];
    }
  • ReadonlyendProductType: FixedAttribute<WindowCovering.EndProductType, any>

    This attribute SHOULD provide more detail about the product type than can be determined from the main category indicated by the Type attribute.

    The table below helps to match the EndProductType attribute with the Type attribute.

    See

    MatterSpecification.v13.Cluster § 5.3.6.17

  • ReadonlyinstalledClosedLimitLift: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            absolutePosition: boolean;
            lift: boolean;
            positionAwareLift: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyinstalledClosedLimitTilt: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            absolutePosition: boolean;
            positionAwareTilt: boolean;
            tilt: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyinstalledOpenLimitLift: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            absolutePosition: boolean;
            lift: boolean;
            positionAwareLift: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyinstalledOpenLimitTilt: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            absolutePosition: boolean;
            positionAwareTilt: boolean;
            tilt: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • Readonlymode: WritableAttribute<TypeFromPartialBitSchema<{
        calibrationMode: BitFlag;
        ledFeedback: BitFlag;
        maintenanceMode: BitFlag;
        motorDirectionReversed: BitFlag;
    }>, any>

    The Mode attribute allows configuration of the window covering, such as: reversing the motor direction, placing the window covering into calibration mode, placing the motor into maintenance mode, disabling the network, and disabling status LEDs.

    In the case a device does not support or implement a specific mode, e.g. the device has a specific installation method and reversal is not relevant or the device does not include a maintenance mode, any write interaction to the Mode attribute, with an unsupported mode bit or any out of bounds bits set, must be ignored and a response containing the status of CONSTRAINT_ERROR will be returned.

    See

    MatterSpecification.v13.Cluster § 5.3.6.22

  • ReadonlynumberOfActuationsLift: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            lift: boolean;
        }];
    }
  • ReadonlynumberOfActuationsTilt: OptionalAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            tilt: boolean;
        }];
    }
  • ReadonlyoperationalStatus: Attribute<TypeFromPartialBitSchema<{
        global: BitFieldEnum<WindowCovering.MovementStatus>;
        lift: BitFieldEnum<WindowCovering.MovementStatus>;
        tilt: BitFieldEnum<WindowCovering.MovementStatus>;
    }>, any>

    Indicates the currently ongoing operations and applies to all type of devices.

    See

    MatterSpecification.v13.Cluster § 5.3.6.16

  • ReadonlyphysicalClosedLimitLift: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            absolutePosition: boolean;
            lift: boolean;
            positionAwareLift: boolean;
        }];
    }
  • ReadonlyphysicalClosedLimitTilt: OptionalFixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            absolutePosition: boolean;
            positionAwareTilt: boolean;
            tilt: boolean;
        }];
    }
  • ReadonlysafetyStatus: 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>

    The SafetyStatus attribute reflects the state of the safety sensors and the common issues preventing movements. By default for nominal operation all flags are cleared (0). A device might support none, one or several bit flags from this attribute (all optional).

    See

    MatterSpecification.v13.Cluster § 5.3.6.23

  • ReadonlytargetPositionLiftPercent100ths: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            lift: boolean;
            positionAwareLift: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlytargetPositionTiltPercent100ths: Attribute<null | number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            positionAwareTilt: boolean;
            tilt: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • Readonlytype: FixedAttribute<WindowCovering.WindowCoveringType, any>

    This attribute shall identify the type of window covering.

    See

    MatterSpecification.v13.Cluster § 5.3.6.2

base

base: undefined

commands

commands: {
    downOrClose: Command<void, void, any>;
    goToLiftPercentage: OptionalCommand<TypeFromFields<{
        liftPercent100thsValue: FieldType<number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            lift: boolean;
            positionAwareLift: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            lift: boolean;
        }];
    };
    goToLiftValue: OptionalCommand<TypeFromFields<{
        liftValue: FieldType<number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            absolutePosition: boolean;
            lift: boolean;
        }];
    };
    goToTiltPercentage: OptionalCommand<TypeFromFields<{
        tiltPercent100thsValue: FieldType<number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            positionAwareTilt: boolean;
            tilt: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            tilt: boolean;
        }];
    };
    goToTiltValue: OptionalCommand<TypeFromFields<{
        tiltValue: FieldType<number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            absolutePosition: boolean;
            tilt: boolean;
        }];
    };
    stopMotion: Command<void, void, any>;
    upOrOpen: Command<void, void, any>;
}

Type declaration

  • ReadonlydownOrClose: Command<void, void, any>

    Upon receipt of this command, the window covering will adjust its position so the physical lift/slide and tilt is at the maximum closed/down position. This will happen as fast as possible. The server attributes supported shall be updated as follows:

    if the PositionAware feature is supported:

    • TargetPositionLiftPercent100ths attribute shall be set to 100.00%.

    • TargetPositionTiltPercent100ths attribute shall be set to 100.00%.

    The server positioning attributes will follow the movements, once the movement has successfully finished, the server attributes shall be updated as follows:

    if the PositionAware feature is supported:

    • CurrentPositionLiftPercent100ths attribute shall be 100.00%.

    • CurrentPositionLiftPercentage attribute shall be 100%.

    • CurrentPositionTiltPercent100ths attribute shall be 100.00%.

    • CurrentPositionTiltPercentage attribute shall be 100%. if the AbsolutePosition feature is supported:

    • CurrentPositionLift attribute shall be equal to the InstalledClosedLimitLift attribute.

    • CurrentPositionTilt attribute shall be equal to the InstalledClosedLimitTilt attribute.

    See

    MatterSpecification.v13.Cluster § 5.3.7.2

  • ReadonlygoToLiftPercentage: OptionalCommand<TypeFromFields<{
        liftPercent100thsValue: FieldType<number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            lift: boolean;
            positionAwareLift: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            lift: boolean;
        }];
    }
  • ReadonlygoToLiftValue: OptionalCommand<TypeFromFields<{
        liftValue: FieldType<number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            absolutePosition: boolean;
            lift: boolean;
        }];
    }
  • ReadonlygoToTiltPercentage: OptionalCommand<TypeFromFields<{
        tiltPercent100thsValue: FieldType<number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            positionAwareTilt: boolean;
            tilt: boolean;
        }];
        optional: true;
        optionalIf: [] | [{
            tilt: boolean;
        }];
    }
  • ReadonlygoToTiltValue: OptionalCommand<TypeFromFields<{
        tiltValue: FieldType<number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            absolutePosition: boolean;
            tilt: boolean;
        }];
    }
  • ReadonlystopMotion: Command<void, void, any>

    Upon receipt of this command, the window covering will stop any adjusting to the physical tilt and lift/slide that is currently occurring. The server attributes supported shall be updated as follows:

    • TargetPositionLiftPercent100ths attribute will be set to CurrentPositionLiftPercent100ths attribute value.

    • TargetPositionTiltPercent100ths attribute will be set to CurrentPositionTiltPercent100ths attribute value.

    See

    MatterSpecification.v13.Cluster § 5.3.7.3

  • ReadonlyupOrOpen: Command<void, void, any>

    Upon receipt of this command, the window covering will adjust its position so the physical lift/slide and tilt is at the maximum open/up position. This will happen as fast as possible. The server attributes shall be updated as follows:

    if the PositionAware feature is supported:

    • TargetPositionLiftPercent100ths attribute shall be set to 0.00%.

    • TargetPositionTiltPercent100ths attribute shall be set to 0.00%.

    The server positioning attributes will follow the movements, once the movement has successfully finished, the server attributes shall be updated as follows:

    if the PositionAware feature is supported:

    • CurrentPositionLiftPercent100ths attribute shall be 0.00%.

    • CurrentPositionLiftPercentage attribute shall be 0%.

    • CurrentPositionTiltPercent100ths attribute shall be 0.00%.

    • CurrentPositionTiltPercentage attribute shall be 0%. if the AbsolutePosition feature is supported:

    • CurrentPositionLift attribute shall be equal to the InstalledOpenLimitLift attribute.

    • CurrentPositionTilt attribute shall be equal to the InstalledOpenLimitTilt attribute.

    See

    MatterSpecification.v13.Cluster § 5.3.7.1

events

events: {}

extensions

extensions: undefined

features

features: {
    absolutePosition: BitFlag;
    lift: BitFlag;
    positionAwareLift: BitFlag;
    positionAwareTilt: BitFlag;
    tilt: BitFlag;
}

Type declaration

  • ReadonlyabsolutePosition: BitFlag

    AbsolutePosition

    The percentage attributes shall indicate the position as a percentage between the InstalledOpenLimits and InstalledClosedLimits attributes of the window covering starting at the open (0.00%).

    As a general rule, absolute positioning (in centimeters or tenth of a degrees) SHOULD NOT be supported for new implementations.

    See

    MatterSpecification.v13.Cluster § 5.3.4.4

  • Readonlylift: BitFlag

    Lift

    The Lift feature applies to window coverings that lift up and down (e.g. for a roller shade, Up and Down is lift Open and Close) or slide left to right (e.g. for a sliding curtain, Left and Right is lift Open and Close).

    See

    MatterSpecification.v13.Cluster § 5.3.4.1

  • ReadonlypositionAwareLift: BitFlag

    PositionAwareLift

    Position aware lift control is supported.

  • ReadonlypositionAwareTilt: BitFlag

    PositionAwareTilt

    Position aware tilt control is supported.

  • Readonlytilt: BitFlag

    Tilt

    The Tilt feature applies to window coverings with vertical or horizontal strips.

    See

    MatterSpecification.v13.Cluster § 5.3.4.2

id

id: Branded<258, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            configStatus: Attribute<TypeFromPartialBitSchema<{
                liftEncoderControlled: BitFlag;
                liftMovementReversed: BitFlag;
                liftPositionAware: BitFlag;
                onlineReserved: BitFlag;
                operational: BitFlag;
                tiltEncoderControlled: BitFlag;
                tiltPositionAware: BitFlag;
            }>, any>;
            currentPositionLift: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionLiftPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionTilt: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            currentPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionTiltPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
            installedClosedLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedClosedLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            mode: WritableAttribute<TypeFromPartialBitSchema<{
                calibrationMode: BitFlag;
                ledFeedback: BitFlag;
                maintenanceMode: BitFlag;
                motorDirectionReversed: BitFlag;
            }>, any>;
            numberOfActuationsLift: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            numberOfActuationsTilt: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            operationalStatus: Attribute<TypeFromPartialBitSchema<{
                global: BitFieldEnum<WindowCovering.MovementStatus>;
                lift: BitFieldEnum<WindowCovering.MovementStatus>;
                tilt: BitFieldEnum<WindowCovering.MovementStatus>;
            }>, any>;
            physicalClosedLimitLift: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            physicalClosedLimitTilt: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            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>;
            targetPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            targetPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
        };
        commands: {
            downOrClose: Command<void, void, any>;
            goToLiftPercentage: OptionalCommand<TypeFromFields<{
                liftPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            goToLiftValue: OptionalCommand<TypeFromFields<{
                liftValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                }];
            };
            goToTiltPercentage: OptionalCommand<TypeFromFields<{
                tiltPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            goToTiltValue: OptionalCommand<TypeFromFields<{
                tiltValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    tilt: boolean;
                }];
            };
            stopMotion: Command<void, void, any>;
            upOrOpen: Command<void, void, any>;
        };
        features: {
            absolutePosition: BitFlag;
            lift: BitFlag;
            positionAwareLift: BitFlag;
            positionAwareTilt: BitFlag;
            tilt: BitFlag;
        };
        id: 258;
        name: "WindowCovering";
        revision: 5;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              configStatus: Attribute<TypeFromPartialBitSchema<{
                  liftEncoderControlled: BitFlag;
                  liftMovementReversed: BitFlag;
                  liftPositionAware: BitFlag;
                  onlineReserved: BitFlag;
                  operational: BitFlag;
                  tiltEncoderControlled: BitFlag;
                  tiltPositionAware: BitFlag;
              }>, any>;
              currentPositionLift: OptionalAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      absolutePosition: boolean;
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
              };
              currentPositionLiftPercent100ths: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              currentPositionLiftPercentage: OptionalAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
              };
              currentPositionTilt: OptionalAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      absolutePosition: boolean;
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
              };
              currentPositionTiltPercent100ths: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              currentPositionTiltPercentage: OptionalAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
              };
              endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
              installedClosedLimitLift: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      absolutePosition: boolean;
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              installedClosedLimitTilt: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      absolutePosition: boolean;
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              installedOpenLimitLift: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      absolutePosition: boolean;
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              installedOpenLimitTilt: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      absolutePosition: boolean;
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              mode: WritableAttribute<TypeFromPartialBitSchema<{
                  calibrationMode: BitFlag;
                  ledFeedback: BitFlag;
                  maintenanceMode: BitFlag;
                  motorDirectionReversed: BitFlag;
              }>, any>;
              numberOfActuationsLift: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      lift: boolean;
                  }];
              };
              numberOfActuationsTilt: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      tilt: boolean;
                  }];
              };
              operationalStatus: Attribute<TypeFromPartialBitSchema<{
                  global: BitFieldEnum<WindowCovering.MovementStatus>;
                  lift: BitFieldEnum<WindowCovering.MovementStatus>;
                  tilt: BitFieldEnum<WindowCovering.MovementStatus>;
              }>, any>;
              physicalClosedLimitLift: OptionalFixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      absolutePosition: boolean;
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
              };
              physicalClosedLimitTilt: OptionalFixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      absolutePosition: boolean;
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
              };
              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>;
              targetPositionLiftPercent100ths: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              targetPositionTiltPercent100ths: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
          };
          commands: {
              downOrClose: Command<void, void, any>;
              goToLiftPercentage: OptionalCommand<TypeFromFields<{
                  liftPercent100thsValue: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      lift: boolean;
                  }];
              };
              goToLiftValue: OptionalCommand<TypeFromFields<{
                  liftValue: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      absolutePosition: boolean;
                      lift: boolean;
                  }];
              };
              goToTiltPercentage: OptionalCommand<TypeFromFields<{
                  tiltPercent100thsValue: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      tilt: boolean;
                  }];
              };
              goToTiltValue: OptionalCommand<TypeFromFields<{
                  tiltValue: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      absolutePosition: boolean;
                      tilt: boolean;
                  }];
              };
              stopMotion: Command<void, void, any>;
              upOrOpen: Command<void, void, any>;
          };
          features: {
              absolutePosition: BitFlag;
              lift: BitFlag;
              positionAwareLift: BitFlag;
              positionAwareTilt: BitFlag;
              tilt: BitFlag;
          };
          id: 258;
          name: "WindowCovering";
          revision: 5;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            configStatus: Attribute<TypeFromPartialBitSchema<{
                liftEncoderControlled: BitFlag;
                liftMovementReversed: BitFlag;
                liftPositionAware: BitFlag;
                onlineReserved: BitFlag;
                operational: BitFlag;
                tiltEncoderControlled: BitFlag;
                tiltPositionAware: BitFlag;
            }>, any>;
            currentPositionLift: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionLiftPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionTilt: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            currentPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionTiltPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
            installedClosedLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedClosedLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            mode: WritableAttribute<TypeFromPartialBitSchema<{
                calibrationMode: BitFlag;
                ledFeedback: BitFlag;
                maintenanceMode: BitFlag;
                motorDirectionReversed: BitFlag;
            }>, any>;
            numberOfActuationsLift: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            numberOfActuationsTilt: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            operationalStatus: Attribute<TypeFromPartialBitSchema<{
                global: BitFieldEnum<WindowCovering.MovementStatus>;
                lift: BitFieldEnum<WindowCovering.MovementStatus>;
                tilt: BitFieldEnum<WindowCovering.MovementStatus>;
            }>, any>;
            physicalClosedLimitLift: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            physicalClosedLimitTilt: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            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>;
            targetPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            targetPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
        };
        commands: {
            downOrClose: Command<void, void, any>;
            goToLiftPercentage: OptionalCommand<TypeFromFields<{
                liftPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            goToLiftValue: OptionalCommand<TypeFromFields<{
                liftValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                }];
            };
            goToTiltPercentage: OptionalCommand<TypeFromFields<{
                tiltPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            goToTiltValue: OptionalCommand<TypeFromFields<{
                tiltValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    tilt: boolean;
                }];
            };
            stopMotion: Command<void, void, any>;
            upOrOpen: Command<void, void, any>;
        };
        features: {
            absolutePosition: BitFlag;
            lift: BitFlag;
            positionAwareLift: BitFlag;
            positionAwareTilt: BitFlag;
            tilt: BitFlag;
        };
        id: 258;
        name: "WindowCovering";
        revision: 5;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            configStatus: Attribute<TypeFromPartialBitSchema<{
                liftEncoderControlled: BitFlag;
                liftMovementReversed: BitFlag;
                liftPositionAware: BitFlag;
                onlineReserved: BitFlag;
                operational: BitFlag;
                tiltEncoderControlled: BitFlag;
                tiltPositionAware: BitFlag;
            }>, any>;
            currentPositionLift: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionLiftPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionTilt: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            currentPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionTiltPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
            installedClosedLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedClosedLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            mode: WritableAttribute<TypeFromPartialBitSchema<{
                calibrationMode: BitFlag;
                ledFeedback: BitFlag;
                maintenanceMode: BitFlag;
                motorDirectionReversed: BitFlag;
            }>, any>;
            numberOfActuationsLift: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            numberOfActuationsTilt: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            operationalStatus: Attribute<TypeFromPartialBitSchema<{
                global: BitFieldEnum<WindowCovering.MovementStatus>;
                lift: BitFieldEnum<WindowCovering.MovementStatus>;
                tilt: BitFieldEnum<WindowCovering.MovementStatus>;
            }>, any>;
            physicalClosedLimitLift: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            physicalClosedLimitTilt: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            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>;
            targetPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            targetPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
        };
        commands: {
            downOrClose: Command<void, void, any>;
            goToLiftPercentage: OptionalCommand<TypeFromFields<{
                liftPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            goToLiftValue: OptionalCommand<TypeFromFields<{
                liftValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                }];
            };
            goToTiltPercentage: OptionalCommand<TypeFromFields<{
                tiltPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            goToTiltValue: OptionalCommand<TypeFromFields<{
                tiltValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    tilt: boolean;
                }];
            };
            stopMotion: Command<void, void, any>;
            upOrOpen: Command<void, void, any>;
        };
        features: {
            absolutePosition: BitFlag;
            lift: BitFlag;
            positionAwareLift: BitFlag;
            positionAwareTilt: BitFlag;
            tilt: BitFlag;
        };
        id: 258;
        name: "WindowCovering";
        revision: 5;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              configStatus: Attribute<TypeFromPartialBitSchema<{
                  liftEncoderControlled: BitFlag;
                  liftMovementReversed: BitFlag;
                  liftPositionAware: BitFlag;
                  onlineReserved: BitFlag;
                  operational: BitFlag;
                  tiltEncoderControlled: BitFlag;
                  tiltPositionAware: BitFlag;
              }>, any>;
              currentPositionLift: OptionalAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      absolutePosition: boolean;
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
              };
              currentPositionLiftPercent100ths: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              currentPositionLiftPercentage: OptionalAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
              };
              currentPositionTilt: OptionalAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      absolutePosition: boolean;
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
              };
              currentPositionTiltPercent100ths: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              currentPositionTiltPercentage: OptionalAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
              };
              endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
              installedClosedLimitLift: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      absolutePosition: boolean;
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              installedClosedLimitTilt: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      absolutePosition: boolean;
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              installedOpenLimitLift: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      absolutePosition: boolean;
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              installedOpenLimitTilt: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      absolutePosition: boolean;
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              mode: WritableAttribute<TypeFromPartialBitSchema<{
                  calibrationMode: BitFlag;
                  ledFeedback: BitFlag;
                  maintenanceMode: BitFlag;
                  motorDirectionReversed: BitFlag;
              }>, any>;
              numberOfActuationsLift: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      lift: boolean;
                  }];
              };
              numberOfActuationsTilt: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      tilt: boolean;
                  }];
              };
              operationalStatus: Attribute<TypeFromPartialBitSchema<{
                  global: BitFieldEnum<WindowCovering.MovementStatus>;
                  lift: BitFieldEnum<WindowCovering.MovementStatus>;
                  tilt: BitFieldEnum<WindowCovering.MovementStatus>;
              }>, any>;
              physicalClosedLimitLift: OptionalFixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      absolutePosition: boolean;
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
              };
              physicalClosedLimitTilt: OptionalFixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      absolutePosition: boolean;
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
              };
              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>;
              targetPositionLiftPercent100ths: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              targetPositionTiltPercent100ths: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
          };
          commands: {
              downOrClose: Command<void, void, any>;
              goToLiftPercentage: OptionalCommand<TypeFromFields<{
                  liftPercent100thsValue: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      lift: boolean;
                  }];
              };
              goToLiftValue: OptionalCommand<TypeFromFields<{
                  liftValue: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      absolutePosition: boolean;
                      lift: boolean;
                  }];
              };
              goToTiltPercentage: OptionalCommand<TypeFromFields<{
                  tiltPercent100thsValue: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      tilt: boolean;
                  }];
              };
              goToTiltValue: OptionalCommand<TypeFromFields<{
                  tiltValue: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      absolutePosition: boolean;
                      tilt: boolean;
                  }];
              };
              stopMotion: Command<void, void, any>;
              upOrOpen: Command<void, void, any>;
          };
          features: {
              absolutePosition: BitFlag;
              lift: BitFlag;
              positionAwareLift: BitFlag;
              positionAwareTilt: BitFlag;
              tilt: BitFlag;
          };
          id: 258;
          name: "WindowCovering";
          revision: 5;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            configStatus: Attribute<TypeFromPartialBitSchema<{
                liftEncoderControlled: BitFlag;
                liftMovementReversed: BitFlag;
                liftPositionAware: BitFlag;
                onlineReserved: BitFlag;
                operational: BitFlag;
                tiltEncoderControlled: BitFlag;
                tiltPositionAware: BitFlag;
            }>, any>;
            currentPositionLift: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionLiftPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionTilt: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            currentPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionTiltPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
            installedClosedLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedClosedLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            mode: WritableAttribute<TypeFromPartialBitSchema<{
                calibrationMode: BitFlag;
                ledFeedback: BitFlag;
                maintenanceMode: BitFlag;
                motorDirectionReversed: BitFlag;
            }>, any>;
            numberOfActuationsLift: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            numberOfActuationsTilt: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            operationalStatus: Attribute<TypeFromPartialBitSchema<{
                global: BitFieldEnum<WindowCovering.MovementStatus>;
                lift: BitFieldEnum<WindowCovering.MovementStatus>;
                tilt: BitFieldEnum<WindowCovering.MovementStatus>;
            }>, any>;
            physicalClosedLimitLift: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            physicalClosedLimitTilt: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            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>;
            targetPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            targetPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
        };
        commands: {
            downOrClose: Command<void, void, any>;
            goToLiftPercentage: OptionalCommand<TypeFromFields<{
                liftPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            goToLiftValue: OptionalCommand<TypeFromFields<{
                liftValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                }];
            };
            goToTiltPercentage: OptionalCommand<TypeFromFields<{
                tiltPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            goToTiltValue: OptionalCommand<TypeFromFields<{
                tiltValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    tilt: boolean;
                }];
            };
            stopMotion: Command<void, void, any>;
            upOrOpen: Command<void, void, any>;
        };
        features: {
            absolutePosition: BitFlag;
            lift: BitFlag;
            positionAwareLift: BitFlag;
            positionAwareTilt: BitFlag;
            tilt: BitFlag;
        };
        id: 258;
        name: "WindowCovering";
        revision: 5;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            configStatus: Attribute<TypeFromPartialBitSchema<{
                liftEncoderControlled: BitFlag;
                liftMovementReversed: BitFlag;
                liftPositionAware: BitFlag;
                onlineReserved: BitFlag;
                operational: BitFlag;
                tiltEncoderControlled: BitFlag;
                tiltPositionAware: BitFlag;
            }>, any>;
            currentPositionLift: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionLiftPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionTilt: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            currentPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionTiltPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
            installedClosedLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedClosedLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            mode: WritableAttribute<TypeFromPartialBitSchema<{
                calibrationMode: BitFlag;
                ledFeedback: BitFlag;
                maintenanceMode: BitFlag;
                motorDirectionReversed: BitFlag;
            }>, any>;
            numberOfActuationsLift: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            numberOfActuationsTilt: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            operationalStatus: Attribute<TypeFromPartialBitSchema<{
                global: BitFieldEnum<WindowCovering.MovementStatus>;
                lift: BitFieldEnum<WindowCovering.MovementStatus>;
                tilt: BitFieldEnum<WindowCovering.MovementStatus>;
            }>, any>;
            physicalClosedLimitLift: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            physicalClosedLimitTilt: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            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>;
            targetPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            targetPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
        };
        commands: {
            downOrClose: Command<void, void, any>;
            goToLiftPercentage: OptionalCommand<TypeFromFields<{
                liftPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            goToLiftValue: OptionalCommand<TypeFromFields<{
                liftValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                }];
            };
            goToTiltPercentage: OptionalCommand<TypeFromFields<{
                tiltPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            goToTiltValue: OptionalCommand<TypeFromFields<{
                tiltValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    tilt: boolean;
                }];
            };
            stopMotion: Command<void, void, any>;
            upOrOpen: Command<void, void, any>;
        };
        features: {
            absolutePosition: BitFlag;
            lift: BitFlag;
            positionAwareLift: BitFlag;
            positionAwareTilt: BitFlag;
            tilt: BitFlag;
        };
        id: 258;
        name: "WindowCovering";
        revision: 5;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          configStatus: {
              liftEncoderControlled?: boolean;
              liftMovementReversed?: boolean;
              liftPositionAware?: boolean;
              onlineReserved?: boolean;
              operational?: boolean;
              tiltEncoderControlled?: boolean;
              tiltPositionAware?: boolean;
          };
          currentPositionLift?: null | number;
          currentPositionLiftPercent100ths?: null | number;
          currentPositionLiftPercentage?: null | number;
          currentPositionTilt?: null | number;
          currentPositionTiltPercent100ths?: null | number;
          currentPositionTiltPercentage?: null | number;
          endProductType: number;
          installedClosedLimitLift?: number;
          installedClosedLimitTilt?: number;
          installedOpenLimitLift?: number;
          installedOpenLimitTilt?: number;
          mode: {
              calibrationMode?: boolean;
              ledFeedback?: boolean;
              maintenanceMode?: boolean;
              motorDirectionReversed?: boolean;
          };
          numberOfActuationsLift?: number;
          numberOfActuationsTilt?: number;
          operationalStatus: {
              global?: number;
              lift?: number;
              tilt?: number;
          };
          physicalClosedLimitLift?: number;
          physicalClosedLimitTilt?: number;
          safetyStatus?: {
              failedCommunication?: boolean;
              hardwareFailure?: boolean;
              manualOperation?: boolean;
              motorJammed?: boolean;
              obstacleDetected?: boolean;
              positionFailure?: boolean;
              power?: boolean;
              protection?: boolean;
              remoteLockout?: boolean;
              stopInput?: boolean;
              tamperDetection?: boolean;
              thermalProtection?: boolean;
          };
          targetPositionLiftPercent100ths?: null | number;
          targetPositionTiltPercent100ths?: null | number;
          type: number;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            configStatus: Attribute<TypeFromPartialBitSchema<{
                liftEncoderControlled: BitFlag;
                liftMovementReversed: BitFlag;
                liftPositionAware: BitFlag;
                onlineReserved: BitFlag;
                operational: BitFlag;
                tiltEncoderControlled: BitFlag;
                tiltPositionAware: BitFlag;
            }>, any>;
            currentPositionLift: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionLiftPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionTilt: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            currentPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionTiltPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
            installedClosedLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedClosedLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            mode: WritableAttribute<TypeFromPartialBitSchema<{
                calibrationMode: BitFlag;
                ledFeedback: BitFlag;
                maintenanceMode: BitFlag;
                motorDirectionReversed: BitFlag;
            }>, any>;
            numberOfActuationsLift: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            numberOfActuationsTilt: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            operationalStatus: Attribute<TypeFromPartialBitSchema<{
                global: BitFieldEnum<WindowCovering.MovementStatus>;
                lift: BitFieldEnum<WindowCovering.MovementStatus>;
                tilt: BitFieldEnum<WindowCovering.MovementStatus>;
            }>, any>;
            physicalClosedLimitLift: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            physicalClosedLimitTilt: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            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>;
            targetPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            targetPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
        };
        commands: {
            downOrClose: Command<void, void, any>;
            goToLiftPercentage: OptionalCommand<TypeFromFields<{
                liftPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            goToLiftValue: OptionalCommand<TypeFromFields<{
                liftValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                }];
            };
            goToTiltPercentage: OptionalCommand<TypeFromFields<{
                tiltPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            goToTiltValue: OptionalCommand<TypeFromFields<{
                tiltValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    tilt: boolean;
                }];
            };
            stopMotion: Command<void, void, any>;
            upOrOpen: Command<void, void, any>;
        };
        features: {
            absolutePosition: BitFlag;
            lift: BitFlag;
            positionAwareLift: BitFlag;
            positionAwareTilt: BitFlag;
            tilt: BitFlag;
        };
        id: 258;
        name: "WindowCovering";
        revision: 5;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            configStatus: Attribute<TypeFromPartialBitSchema<{
                liftEncoderControlled: BitFlag;
                liftMovementReversed: BitFlag;
                liftPositionAware: BitFlag;
                onlineReserved: BitFlag;
                operational: BitFlag;
                tiltEncoderControlled: BitFlag;
                tiltPositionAware: BitFlag;
            }>, any>;
            currentPositionLift: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionLiftPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionTilt: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            currentPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionTiltPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
            installedClosedLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedClosedLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            mode: WritableAttribute<TypeFromPartialBitSchema<{
                calibrationMode: BitFlag;
                ledFeedback: BitFlag;
                maintenanceMode: BitFlag;
                motorDirectionReversed: BitFlag;
            }>, any>;
            numberOfActuationsLift: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            numberOfActuationsTilt: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            operationalStatus: Attribute<TypeFromPartialBitSchema<{
                global: BitFieldEnum<WindowCovering.MovementStatus>;
                lift: BitFieldEnum<WindowCovering.MovementStatus>;
                tilt: BitFieldEnum<WindowCovering.MovementStatus>;
            }>, any>;
            physicalClosedLimitLift: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            physicalClosedLimitTilt: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            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>;
            targetPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            targetPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
        };
        commands: {
            downOrClose: Command<void, void, any>;
            goToLiftPercentage: OptionalCommand<TypeFromFields<{
                liftPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            goToLiftValue: OptionalCommand<TypeFromFields<{
                liftValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                }];
            };
            goToTiltPercentage: OptionalCommand<TypeFromFields<{
                tiltPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            goToTiltValue: OptionalCommand<TypeFromFields<{
                tiltValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    tilt: boolean;
                }];
            };
            stopMotion: Command<void, void, any>;
            upOrOpen: Command<void, void, any>;
        };
        features: {
            absolutePosition: BitFlag;
            lift: BitFlag;
            positionAwareLift: BitFlag;
            positionAwareTilt: BitFlag;
            tilt: BitFlag;
        };
        id: 258;
        name: "WindowCovering";
        revision: 5;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              configStatus: Attribute<TypeFromPartialBitSchema<{
                  liftEncoderControlled: BitFlag;
                  liftMovementReversed: BitFlag;
                  liftPositionAware: BitFlag;
                  onlineReserved: BitFlag;
                  operational: BitFlag;
                  tiltEncoderControlled: BitFlag;
                  tiltPositionAware: BitFlag;
              }>, any>;
              currentPositionLift: OptionalAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      absolutePosition: boolean;
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
              };
              currentPositionLiftPercent100ths: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              currentPositionLiftPercentage: OptionalAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
              };
              currentPositionTilt: OptionalAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      absolutePosition: boolean;
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
              };
              currentPositionTiltPercent100ths: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              currentPositionTiltPercentage: OptionalAttribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
              };
              endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
              installedClosedLimitLift: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      absolutePosition: boolean;
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              installedClosedLimitTilt: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      absolutePosition: boolean;
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              installedOpenLimitLift: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      absolutePosition: boolean;
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              installedOpenLimitTilt: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      absolutePosition: boolean;
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              mode: WritableAttribute<TypeFromPartialBitSchema<{
                  calibrationMode: BitFlag;
                  ledFeedback: BitFlag;
                  maintenanceMode: BitFlag;
                  motorDirectionReversed: BitFlag;
              }>, any>;
              numberOfActuationsLift: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      lift: boolean;
                  }];
              };
              numberOfActuationsTilt: OptionalAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      tilt: boolean;
                  }];
              };
              operationalStatus: Attribute<TypeFromPartialBitSchema<{
                  global: BitFieldEnum<WindowCovering.MovementStatus>;
                  lift: BitFieldEnum<WindowCovering.MovementStatus>;
                  tilt: BitFieldEnum<WindowCovering.MovementStatus>;
              }>, any>;
              physicalClosedLimitLift: OptionalFixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      absolutePosition: boolean;
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
              };
              physicalClosedLimitTilt: OptionalFixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      absolutePosition: boolean;
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
              };
              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>;
              targetPositionLiftPercent100ths: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              targetPositionTiltPercent100ths: Attribute<null | number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
          };
          commands: {
              downOrClose: Command<void, void, any>;
              goToLiftPercentage: OptionalCommand<TypeFromFields<{
                  liftPercent100thsValue: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      lift: boolean;
                      positionAwareLift: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      lift: boolean;
                  }];
              };
              goToLiftValue: OptionalCommand<TypeFromFields<{
                  liftValue: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      absolutePosition: boolean;
                      lift: boolean;
                  }];
              };
              goToTiltPercentage: OptionalCommand<TypeFromFields<{
                  tiltPercent100thsValue: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      positionAwareTilt: boolean;
                      tilt: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | [{
                      tilt: boolean;
                  }];
              };
              goToTiltValue: OptionalCommand<TypeFromFields<{
                  tiltValue: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      absolutePosition: boolean;
                      tilt: boolean;
                  }];
              };
              stopMotion: Command<void, void, any>;
              upOrOpen: Command<void, void, any>;
          };
          features: {
              absolutePosition: BitFlag;
              lift: BitFlag;
              positionAwareLift: BitFlag;
              positionAwareTilt: BitFlag;
              tilt: BitFlag;
          };
          id: 258;
          name: "WindowCovering";
          revision: 5;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            configStatus: Attribute<TypeFromPartialBitSchema<{
                liftEncoderControlled: BitFlag;
                liftMovementReversed: BitFlag;
                liftPositionAware: BitFlag;
                onlineReserved: BitFlag;
                operational: BitFlag;
                tiltEncoderControlled: BitFlag;
                tiltPositionAware: BitFlag;
            }>, any>;
            currentPositionLift: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionLiftPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            currentPositionTilt: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            currentPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            currentPositionTiltPercentage: OptionalAttribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
            installedClosedLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedClosedLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitLift: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            installedOpenLimitTilt: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            mode: WritableAttribute<TypeFromPartialBitSchema<{
                calibrationMode: BitFlag;
                ledFeedback: BitFlag;
                maintenanceMode: BitFlag;
                motorDirectionReversed: BitFlag;
            }>, any>;
            numberOfActuationsLift: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            numberOfActuationsTilt: OptionalAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            operationalStatus: Attribute<TypeFromPartialBitSchema<{
                global: BitFieldEnum<WindowCovering.MovementStatus>;
                lift: BitFieldEnum<WindowCovering.MovementStatus>;
                tilt: BitFieldEnum<WindowCovering.MovementStatus>;
            }>, any>;
            physicalClosedLimitLift: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
            };
            physicalClosedLimitTilt: OptionalFixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
            };
            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>;
            targetPositionLiftPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            targetPositionTiltPercent100ths: Attribute<null | number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
        };
        commands: {
            downOrClose: Command<void, void, any>;
            goToLiftPercentage: OptionalCommand<TypeFromFields<{
                liftPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    lift: boolean;
                    positionAwareLift: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    lift: boolean;
                }];
            };
            goToLiftValue: OptionalCommand<TypeFromFields<{
                liftValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    lift: boolean;
                }];
            };
            goToTiltPercentage: OptionalCommand<TypeFromFields<{
                tiltPercent100thsValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    positionAwareTilt: boolean;
                    tilt: boolean;
                }];
                optional: true;
                optionalIf: [] | [{
                    tilt: boolean;
                }];
            };
            goToTiltValue: OptionalCommand<TypeFromFields<{
                tiltValue: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    absolutePosition: boolean;
                    tilt: boolean;
                }];
            };
            stopMotion: Command<void, void, any>;
            upOrOpen: Command<void, void, any>;
        };
        features: {
            absolutePosition: BitFlag;
            lift: BitFlag;
            positionAwareLift: BitFlag;
            positionAwareTilt: BitFlag;
            tilt: BitFlag;
        };
        id: 258;
        name: "WindowCovering";
        revision: 5;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods