Interface Cluster

The window covering cluster provides an interface for controlling and adjusting automatic window coverings such as drapery motors, automatic shades, curtains and blinds.

Per the Matter specification you cannot use WindowCoveringCluster without enabling certain feature combinations. You must use the with factory method to obtain a working cluster.

See

MatterSpecification.v13.Cluster § 5.3

interface Cluster {
    id: ClusterId;
    name: string;
    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>;
            endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
            mode: WritableAttribute<TypeFromPartialBitSchema<{
                calibrationMode: BitFlag;
                ledFeedback: BitFlag;
                maintenanceMode: BitFlag;
                motorDirectionReversed: BitFlag;
            }>, any>;
            operationalStatus: Attribute<TypeFromPartialBitSchema<{
                global: BitFieldEnum<WindowCovering.MovementStatus>;
                lift: BitFieldEnum<WindowCovering.MovementStatus>;
                tilt: BitFieldEnum<WindowCovering.MovementStatus>;
            }>, any>;
            safetyStatus: OptionalAttribute<TypeFromPartialBitSchema<{
                failedCommunication: BitFlag;
                hardwareFailure: BitFlag;
                manualOperation: BitFlag;
                motorJammed: BitFlag;
                obstacleDetected: BitFlag;
                positionFailure: BitFlag;
                power: BitFlag;
                protection: BitFlag;
                remoteLockout: BitFlag;
                stopInput: BitFlag;
                tamperDetection: BitFlag;
                thermalProtection: BitFlag;
            }>, any>;
            type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
        };
        commands: {
            downOrClose: Command<void, void, any>;
            stopMotion: Command<void, void, any>;
            upOrOpen: Command<void, void, any>;
        };
        extensions: readonly [{
            component: {
                attributes: {
                    currentPositionLift: OptionalAttribute<null | number, any>;
                    installedClosedLimitLift: Attribute<number, any>;
                    installedOpenLimitLift: Attribute<number, any>;
                    physicalClosedLimitLift: OptionalFixedAttribute<number, any>;
                };
            };
            flags: {
                absolutePosition: true;
                lift: true;
                positionAwareLift: true;
            };
        }, {
            component: {
                attributes: {
                    currentPositionTilt: OptionalAttribute<null | number, any>;
                    installedClosedLimitTilt: Attribute<number, any>;
                    installedOpenLimitTilt: Attribute<number, any>;
                    physicalClosedLimitTilt: OptionalFixedAttribute<number, any>;
                };
            };
            flags: {
                absolutePosition: true;
                positionAwareTilt: true;
                tilt: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfActuationsLift: OptionalAttribute<number, any>;
                };
                commands: {
                    goToLiftPercentage: OptionalCommand<TypeFromFields<{
                        liftPercent100thsValue: ...;
                    }>, void, any>;
                };
            };
            flags: {
                lift: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfActuationsTilt: OptionalAttribute<number, any>;
                };
                commands: {
                    goToTiltPercentage: OptionalCommand<TypeFromFields<{
                        tiltPercent100thsValue: ...;
                    }>, void, any>;
                };
            };
            flags: {
                tilt: true;
            };
        }, {
            component: {
                attributes: {
                    currentPositionLiftPercent100ths: Attribute<null | number, any>;
                    currentPositionLiftPercentage: OptionalAttribute<null | number, any>;
                    targetPositionLiftPercent100ths: Attribute<null | number, any>;
                };
                commands: {
                    goToLiftPercentage: Command<TypeFromFields<{
                        liftPercent100thsValue: ...;
                    }>, void, any>;
                };
            };
            flags: {
                lift: true;
                positionAwareLift: true;
            };
        }, {
            component: {
                attributes: {
                    currentPositionTiltPercent100ths: Attribute<null | number, any>;
                    currentPositionTiltPercentage: OptionalAttribute<null | number, any>;
                    targetPositionTiltPercent100ths: Attribute<null | number, any>;
                };
                commands: {
                    goToTiltPercentage: Command<TypeFromFields<{
                        tiltPercent100thsValue: ...;
                    }>, void, any>;
                };
            };
            flags: {
                positionAwareTilt: true;
                tilt: true;
            };
        }, {
            component: {
                commands: {
                    goToLiftValue: OptionalCommand<TypeFromFields<{
                        liftValue: ...;
                    }>, void, any>;
                };
            };
            flags: {
                absolutePosition: true;
                lift: true;
            };
        }, {
            component: {
                commands: {
                    goToTiltValue: OptionalCommand<TypeFromFields<{
                        tiltValue: ...;
                    }>, void, any>;
                };
            };
            flags: {
                absolutePosition: true;
                tilt: true;
            };
        }, {
            component: false;
            flags: {
                lift: false;
                positionAwareLift: true;
            };
        }, {
            component: false;
            flags: {
                positionAwareTilt: true;
                tilt: false;
            };
        }, {
            component: false;
            flags: {
                lift: false;
                tilt: false;
            };
        }];
        features: {
            absolutePosition: BitFlag;
            lift: BitFlag;
            positionAwareLift: BitFlag;
            positionAwareTilt: BitFlag;
            tilt: BitFlag;
        };
        id: 258;
        name: "WindowCovering";
        revision: 5;
    }>, SelectionT>);
}

Hierarchy (view full)

Properties

id name with

Properties

id

id: ClusterId

name

name: string

with

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>;
        endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
        mode: WritableAttribute<TypeFromPartialBitSchema<{
            calibrationMode: BitFlag;
            ledFeedback: BitFlag;
            maintenanceMode: BitFlag;
            motorDirectionReversed: BitFlag;
        }>, any>;
        operationalStatus: Attribute<TypeFromPartialBitSchema<{
            global: BitFieldEnum<WindowCovering.MovementStatus>;
            lift: BitFieldEnum<WindowCovering.MovementStatus>;
            tilt: BitFieldEnum<WindowCovering.MovementStatus>;
        }>, any>;
        safetyStatus: OptionalAttribute<TypeFromPartialBitSchema<{
            failedCommunication: BitFlag;
            hardwareFailure: BitFlag;
            manualOperation: BitFlag;
            motorJammed: BitFlag;
            obstacleDetected: BitFlag;
            positionFailure: BitFlag;
            power: BitFlag;
            protection: BitFlag;
            remoteLockout: BitFlag;
            stopInput: BitFlag;
            tamperDetection: BitFlag;
            thermalProtection: BitFlag;
        }>, any>;
        type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
    };
    commands: {
        downOrClose: Command<void, void, any>;
        stopMotion: Command<void, void, any>;
        upOrOpen: Command<void, void, any>;
    };
    extensions: readonly [{
        component: {
            attributes: {
                currentPositionLift: OptionalAttribute<null | number, any>;
                installedClosedLimitLift: Attribute<number, any>;
                installedOpenLimitLift: Attribute<number, any>;
                physicalClosedLimitLift: OptionalFixedAttribute<number, any>;
            };
        };
        flags: {
            absolutePosition: true;
            lift: true;
            positionAwareLift: true;
        };
    }, {
        component: {
            attributes: {
                currentPositionTilt: OptionalAttribute<null | number, any>;
                installedClosedLimitTilt: Attribute<number, any>;
                installedOpenLimitTilt: Attribute<number, any>;
                physicalClosedLimitTilt: OptionalFixedAttribute<number, any>;
            };
        };
        flags: {
            absolutePosition: true;
            positionAwareTilt: true;
            tilt: true;
        };
    }, {
        component: {
            attributes: {
                numberOfActuationsLift: OptionalAttribute<number, any>;
            };
            commands: {
                goToLiftPercentage: OptionalCommand<TypeFromFields<{
                    liftPercent100thsValue: ...;
                }>, void, any>;
            };
        };
        flags: {
            lift: true;
        };
    }, {
        component: {
            attributes: {
                numberOfActuationsTilt: OptionalAttribute<number, any>;
            };
            commands: {
                goToTiltPercentage: OptionalCommand<TypeFromFields<{
                    tiltPercent100thsValue: ...;
                }>, void, any>;
            };
        };
        flags: {
            tilt: true;
        };
    }, {
        component: {
            attributes: {
                currentPositionLiftPercent100ths: Attribute<null | number, any>;
                currentPositionLiftPercentage: OptionalAttribute<null | number, any>;
                targetPositionLiftPercent100ths: Attribute<null | number, any>;
            };
            commands: {
                goToLiftPercentage: Command<TypeFromFields<{
                    liftPercent100thsValue: ...;
                }>, void, any>;
            };
        };
        flags: {
            lift: true;
            positionAwareLift: true;
        };
    }, {
        component: {
            attributes: {
                currentPositionTiltPercent100ths: Attribute<null | number, any>;
                currentPositionTiltPercentage: OptionalAttribute<null | number, any>;
                targetPositionTiltPercent100ths: Attribute<null | number, any>;
            };
            commands: {
                goToTiltPercentage: Command<TypeFromFields<{
                    tiltPercent100thsValue: ...;
                }>, void, any>;
            };
        };
        flags: {
            positionAwareTilt: true;
            tilt: true;
        };
    }, {
        component: {
            commands: {
                goToLiftValue: OptionalCommand<TypeFromFields<{
                    liftValue: ...;
                }>, void, any>;
            };
        };
        flags: {
            absolutePosition: true;
            lift: true;
        };
    }, {
        component: {
            commands: {
                goToTiltValue: OptionalCommand<TypeFromFields<{
                    tiltValue: ...;
                }>, void, any>;
            };
        };
        flags: {
            absolutePosition: true;
            tilt: true;
        };
    }, {
        component: false;
        flags: {
            lift: false;
            positionAwareLift: true;
        };
    }, {
        component: false;
        flags: {
            positionAwareTilt: true;
            tilt: false;
        };
    }, {
        component: false;
        flags: {
            lift: false;
            tilt: false;
        };
    }];
    features: {
        absolutePosition: BitFlag;
        lift: BitFlag;
        positionAwareLift: BitFlag;
        positionAwareTilt: BitFlag;
        tilt: BitFlag;
    };
    id: 258;
    name: "WindowCovering";
    revision: 5;
}>, SelectionT>)

Type declaration

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

      Parameters

      Returns Of<Of<{
          attributes: {
              configStatus: Attribute<TypeFromPartialBitSchema<{
                  liftEncoderControlled: BitFlag;
                  liftMovementReversed: BitFlag;
                  liftPositionAware: BitFlag;
                  onlineReserved: BitFlag;
                  operational: BitFlag;
                  tiltEncoderControlled: BitFlag;
                  tiltPositionAware: BitFlag;
              }>, any>;
              endProductType: FixedAttribute<WindowCovering.EndProductType, any>;
              mode: WritableAttribute<TypeFromPartialBitSchema<{
                  calibrationMode: BitFlag;
                  ledFeedback: BitFlag;
                  maintenanceMode: BitFlag;
                  motorDirectionReversed: BitFlag;
              }>, any>;
              operationalStatus: Attribute<TypeFromPartialBitSchema<{
                  global: BitFieldEnum<WindowCovering.MovementStatus>;
                  lift: BitFieldEnum<WindowCovering.MovementStatus>;
                  tilt: BitFieldEnum<WindowCovering.MovementStatus>;
              }>, any>;
              safetyStatus: OptionalAttribute<TypeFromPartialBitSchema<{
                  failedCommunication: BitFlag;
                  hardwareFailure: BitFlag;
                  manualOperation: BitFlag;
                  motorJammed: BitFlag;
                  obstacleDetected: BitFlag;
                  positionFailure: BitFlag;
                  power: BitFlag;
                  protection: BitFlag;
                  remoteLockout: BitFlag;
                  stopInput: BitFlag;
                  tamperDetection: BitFlag;
                  thermalProtection: BitFlag;
              }>, any>;
              type: FixedAttribute<WindowCovering.WindowCoveringType, any>;
          };
          commands: {
              downOrClose: Command<void, void, any>;
              stopMotion: Command<void, void, any>;
              upOrOpen: Command<void, void, any>;
          };
          extensions: readonly [{
              component: {
                  attributes: {
                      currentPositionLift: OptionalAttribute<null | number, any>;
                      installedClosedLimitLift: Attribute<number, any>;
                      installedOpenLimitLift: Attribute<number, any>;
                      physicalClosedLimitLift: OptionalFixedAttribute<number, any>;
                  };
              };
              flags: {
                  absolutePosition: true;
                  lift: true;
                  positionAwareLift: true;
              };
          }, {
              component: {
                  attributes: {
                      currentPositionTilt: OptionalAttribute<null | number, any>;
                      installedClosedLimitTilt: Attribute<number, any>;
                      installedOpenLimitTilt: Attribute<number, any>;
                      physicalClosedLimitTilt: OptionalFixedAttribute<number, any>;
                  };
              };
              flags: {
                  absolutePosition: true;
                  positionAwareTilt: true;
                  tilt: true;
              };
          }, {
              component: {
                  attributes: {
                      numberOfActuationsLift: OptionalAttribute<number, any>;
                  };
                  commands: {
                      goToLiftPercentage: OptionalCommand<TypeFromFields<{
                          liftPercent100thsValue: ...;
                      }>, void, any>;
                  };
              };
              flags: {
                  lift: true;
              };
          }, {
              component: {
                  attributes: {
                      numberOfActuationsTilt: OptionalAttribute<number, any>;
                  };
                  commands: {
                      goToTiltPercentage: OptionalCommand<TypeFromFields<{
                          tiltPercent100thsValue: ...;
                      }>, void, any>;
                  };
              };
              flags: {
                  tilt: true;
              };
          }, {
              component: {
                  attributes: {
                      currentPositionLiftPercent100ths: Attribute<null | number, any>;
                      currentPositionLiftPercentage: OptionalAttribute<null | number, any>;
                      targetPositionLiftPercent100ths: Attribute<null | number, any>;
                  };
                  commands: {
                      goToLiftPercentage: Command<TypeFromFields<{
                          liftPercent100thsValue: ...;
                      }>, void, any>;
                  };
              };
              flags: {
                  lift: true;
                  positionAwareLift: true;
              };
          }, {
              component: {
                  attributes: {
                      currentPositionTiltPercent100ths: Attribute<null | number, any>;
                      currentPositionTiltPercentage: OptionalAttribute<null | number, any>;
                      targetPositionTiltPercent100ths: Attribute<null | number, any>;
                  };
                  commands: {
                      goToTiltPercentage: Command<TypeFromFields<{
                          tiltPercent100thsValue: ...;
                      }>, void, any>;
                  };
              };
              flags: {
                  positionAwareTilt: true;
                  tilt: true;
              };
          }, {
              component: {
                  commands: {
                      goToLiftValue: OptionalCommand<TypeFromFields<{
                          liftValue: ...;
                      }>, void, any>;
                  };
              };
              flags: {
                  absolutePosition: true;
                  lift: true;
              };
          }, {
              component: {
                  commands: {
                      goToTiltValue: OptionalCommand<TypeFromFields<{
                          tiltValue: ...;
                      }>, void, any>;
                  };
              };
              flags: {
                  absolutePosition: true;
                  tilt: true;
              };
          }, {
              component: false;
              flags: {
                  lift: false;
                  positionAwareLift: true;
              };
          }, {
              component: false;
              flags: {
                  positionAwareTilt: true;
                  tilt: false;
              };
          }, {
              component: false;
              flags: {
                  lift: false;
                  tilt: false;
              };
          }];
          features: {
              absolutePosition: BitFlag;
              lift: BitFlag;
              positionAwareLift: BitFlag;
              positionAwareTilt: BitFlag;
              tilt: BitFlag;
          };
          id: 258;
          name: "WindowCovering";
          revision: 5;
      }>, SelectionT>

Settings

Member Visibility

On This Page

Properties