Interface Cluster

This cluster provides a way to access options associated with the operation of a laundry washer device type.

LaundryWasherControlsCluster supports optional features that you can enable with the LaundryWasherControlsCluster.with() factory method.

See

MatterSpecification.v13.Cluster § 8.6

interface Cluster {
    attributes: {};
    base: undefined;
    commands: {};
    events: {};
    extensions: readonly [{
        component: {
            attributes: {
                spinSpeedCurrent: WritableAttribute<null | number, any>;
                spinSpeeds: Attribute<string[], any>;
            };
        };
        flags: {
            spin: true;
        };
    }, {
        component: {
            attributes: {
                numberOfRinses: WritableAttribute<LaundryWasherControls.NumberOfRinses, any>;
                supportedRinses: Attribute<LaundryWasherControls.NumberOfRinses[], any>;
            };
        };
        flags: {
            rinse: true;
        };
    }];
    features: {
        rinse: BitFlag;
        spin: BitFlag;
    };
    id: Branded<83, "ClusterId">;
    name: "LaundryWasherControls";
    revision: 1;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        extensions: readonly [{
            component: {
                attributes: {
                    spinSpeedCurrent: WritableAttribute<null | number, any>;
                    spinSpeeds: Attribute<string[], any>;
                };
            };
            flags: {
                spin: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfRinses: WritableAttribute<LaundryWasherControls.NumberOfRinses, any>;
                    supportedRinses: Attribute<LaundryWasherControls.NumberOfRinses[], any>;
                };
            };
            flags: {
                rinse: true;
            };
        }];
        features: {
            rinse: BitFlag;
            spin: BitFlag;
        };
        id: 83;
        name: "LaundryWasherControls";
        revision: 1;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        extensions: readonly [{
            component: {
                attributes: {
                    spinSpeedCurrent: WritableAttribute<null | number, any>;
                    spinSpeeds: Attribute<string[], any>;
                };
            };
            flags: {
                spin: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfRinses: WritableAttribute<LaundryWasherControls.NumberOfRinses, any>;
                    supportedRinses: Attribute<LaundryWasherControls.NumberOfRinses[], any>;
                };
            };
            flags: {
                rinse: true;
            };
        }];
        features: {
            rinse: BitFlag;
            spin: BitFlag;
        };
        id: 83;
        name: "LaundryWasherControls";
        revision: 1;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        extensions: readonly [{
            component: {
                attributes: {
                    spinSpeedCurrent: WritableAttribute<null | number, any>;
                    spinSpeeds: Attribute<string[], any>;
                };
            };
            flags: {
                spin: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfRinses: WritableAttribute<LaundryWasherControls.NumberOfRinses, any>;
                    supportedRinses: Attribute<LaundryWasherControls.NumberOfRinses[], any>;
                };
            };
            flags: {
                rinse: true;
            };
        }];
        features: {
            rinse: BitFlag;
            spin: BitFlag;
        };
        id: 83;
        name: "LaundryWasherControls";
        revision: 1;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        extensions: readonly [{
            component: {
                attributes: {
                    spinSpeedCurrent: WritableAttribute<null | number, any>;
                    spinSpeeds: Attribute<string[], any>;
                };
            };
            flags: {
                spin: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfRinses: WritableAttribute<LaundryWasherControls.NumberOfRinses, any>;
                    supportedRinses: Attribute<LaundryWasherControls.NumberOfRinses[], any>;
                };
            };
            flags: {
                rinse: true;
            };
        }];
        features: {
            rinse: BitFlag;
            spin: BitFlag;
        };
        id: 83;
        name: "LaundryWasherControls";
        revision: 1;
    }>, SelectionT>;
}

Hierarchy (view full)

Properties

attributes base commands events extensions features id name revision supportedFeatures unknown

Methods

alter enable set with

Properties

attributes

attributes: {}

base

base: undefined

commands

commands: {}

events

events: {}

extensions

extensions: readonly [{
    component: {
        attributes: {
            spinSpeedCurrent: WritableAttribute<null | number, any>;
            spinSpeeds: Attribute<string[], any>;
        };
    };
    flags: {
        spin: true;
    };
}, {
    component: {
        attributes: {
            numberOfRinses: WritableAttribute<LaundryWasherControls.NumberOfRinses, any>;
            supportedRinses: Attribute<LaundryWasherControls.NumberOfRinses[], any>;
        };
    };
    flags: {
        rinse: true;
    };
}]

features

features: {
    rinse: BitFlag;
    spin: BitFlag;
}

Type declaration

  • Readonlyrinse: BitFlag

    Rinse

    This feature indicates multiple rinse cycles are supported in at least one supported mode. Note that some modes may not support selection of the number of rinse cycles even if this feature is supported.

    See

    MatterSpecification.v13.Cluster § 8.6.4.2

  • Readonlyspin: BitFlag

    Spin

    This feature indicates multiple spin speeds are supported in at least one supported mode. Note that some modes may not support multiple spin speeds even if this feature is supported.

    See

    MatterSpecification.v13.Cluster § 8.6.4.1

id

id: Branded<83, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        extensions: readonly [{
            component: {
                attributes: {
                    spinSpeedCurrent: WritableAttribute<null | number, any>;
                    spinSpeeds: Attribute<string[], any>;
                };
            };
            flags: {
                spin: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfRinses: WritableAttribute<LaundryWasherControls.NumberOfRinses, any>;
                    supportedRinses: Attribute<LaundryWasherControls.NumberOfRinses[], any>;
                };
            };
            flags: {
                rinse: true;
            };
        }];
        features: {
            rinse: BitFlag;
            spin: BitFlag;
        };
        id: 83;
        name: "LaundryWasherControls";
        revision: 1;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          extensions: readonly [{
              component: {
                  attributes: {
                      spinSpeedCurrent: WritableAttribute<null | number, any>;
                      spinSpeeds: Attribute<string[], any>;
                  };
              };
              flags: {
                  spin: true;
              };
          }, {
              component: {
                  attributes: {
                      numberOfRinses: WritableAttribute<LaundryWasherControls.NumberOfRinses, any>;
                      supportedRinses: Attribute<LaundryWasherControls.NumberOfRinses[], any>;
                  };
              };
              flags: {
                  rinse: true;
              };
          }];
          features: {
              rinse: BitFlag;
              spin: BitFlag;
          };
          id: 83;
          name: "LaundryWasherControls";
          revision: 1;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        extensions: readonly [{
            component: {
                attributes: {
                    spinSpeedCurrent: WritableAttribute<null | number, any>;
                    spinSpeeds: Attribute<string[], any>;
                };
            };
            flags: {
                spin: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfRinses: WritableAttribute<LaundryWasherControls.NumberOfRinses, any>;
                    supportedRinses: Attribute<LaundryWasherControls.NumberOfRinses[], any>;
                };
            };
            flags: {
                rinse: true;
            };
        }];
        features: {
            rinse: BitFlag;
            spin: BitFlag;
        };
        id: 83;
        name: "LaundryWasherControls";
        revision: 1;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        extensions: readonly [{
            component: {
                attributes: {
                    spinSpeedCurrent: WritableAttribute<null | number, any>;
                    spinSpeeds: Attribute<string[], any>;
                };
            };
            flags: {
                spin: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfRinses: WritableAttribute<LaundryWasherControls.NumberOfRinses, any>;
                    supportedRinses: Attribute<LaundryWasherControls.NumberOfRinses[], any>;
                };
            };
            flags: {
                rinse: true;
            };
        }];
        features: {
            rinse: BitFlag;
            spin: BitFlag;
        };
        id: 83;
        name: "LaundryWasherControls";
        revision: 1;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          extensions: readonly [{
              component: {
                  attributes: {
                      spinSpeedCurrent: WritableAttribute<null | number, any>;
                      spinSpeeds: Attribute<string[], any>;
                  };
              };
              flags: {
                  spin: true;
              };
          }, {
              component: {
                  attributes: {
                      numberOfRinses: WritableAttribute<LaundryWasherControls.NumberOfRinses, any>;
                      supportedRinses: Attribute<LaundryWasherControls.NumberOfRinses[], any>;
                  };
              };
              flags: {
                  rinse: true;
              };
          }];
          features: {
              rinse: BitFlag;
              spin: BitFlag;
          };
          id: 83;
          name: "LaundryWasherControls";
          revision: 1;
      }>>

    Parameters

    Returns WithFlags<Of<{
        extensions: readonly [{
            component: {
                attributes: {
                    spinSpeedCurrent: WritableAttribute<null | number, any>;
                    spinSpeeds: Attribute<string[], any>;
                };
            };
            flags: {
                spin: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfRinses: WritableAttribute<LaundryWasherControls.NumberOfRinses, any>;
                    supportedRinses: Attribute<LaundryWasherControls.NumberOfRinses[], any>;
                };
            };
            flags: {
                rinse: true;
            };
        }];
        features: {
            rinse: BitFlag;
            spin: BitFlag;
        };
        id: 83;
        name: "LaundryWasherControls";
        revision: 1;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        extensions: readonly [{
            component: {
                attributes: {
                    spinSpeedCurrent: WritableAttribute<null | number, any>;
                    spinSpeeds: Attribute<string[], any>;
                };
            };
            flags: {
                spin: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfRinses: WritableAttribute<LaundryWasherControls.NumberOfRinses, any>;
                    supportedRinses: Attribute<LaundryWasherControls.NumberOfRinses[], any>;
                };
            };
            flags: {
                rinse: true;
            };
        }];
        features: {
            rinse: BitFlag;
            spin: BitFlag;
        };
        id: 83;
        name: "LaundryWasherControls";
        revision: 1;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {}

    Parameters

    Returns WithValues<Of<{
        extensions: readonly [{
            component: {
                attributes: {
                    spinSpeedCurrent: WritableAttribute<null | number, any>;
                    spinSpeeds: Attribute<string[], any>;
                };
            };
            flags: {
                spin: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfRinses: WritableAttribute<LaundryWasherControls.NumberOfRinses, any>;
                    supportedRinses: Attribute<LaundryWasherControls.NumberOfRinses[], any>;
                };
            };
            flags: {
                rinse: true;
            };
        }];
        features: {
            rinse: BitFlag;
            spin: BitFlag;
        };
        id: 83;
        name: "LaundryWasherControls";
        revision: 1;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        extensions: readonly [{
            component: {
                attributes: {
                    spinSpeedCurrent: WritableAttribute<null | number, any>;
                    spinSpeeds: Attribute<string[], any>;
                };
            };
            flags: {
                spin: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfRinses: WritableAttribute<LaundryWasherControls.NumberOfRinses, any>;
                    supportedRinses: Attribute<LaundryWasherControls.NumberOfRinses[], any>;
                };
            };
            flags: {
                rinse: true;
            };
        }];
        features: {
            rinse: BitFlag;
            spin: BitFlag;
        };
        id: 83;
        name: "LaundryWasherControls";
        revision: 1;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          extensions: readonly [{
              component: {
                  attributes: {
                      spinSpeedCurrent: WritableAttribute<null | number, any>;
                      spinSpeeds: Attribute<string[], any>;
                  };
              };
              flags: {
                  spin: true;
              };
          }, {
              component: {
                  attributes: {
                      numberOfRinses: WritableAttribute<LaundryWasherControls.NumberOfRinses, any>;
                      supportedRinses: Attribute<LaundryWasherControls.NumberOfRinses[], any>;
                  };
              };
              flags: {
                  rinse: true;
              };
          }];
          features: {
              rinse: BitFlag;
              spin: BitFlag;
          };
          id: 83;
          name: "LaundryWasherControls";
          revision: 1;
      }>>

    Parameters

    Returns Of<Of<{
        extensions: readonly [{
            component: {
                attributes: {
                    spinSpeedCurrent: WritableAttribute<null | number, any>;
                    spinSpeeds: Attribute<string[], any>;
                };
            };
            flags: {
                spin: true;
            };
        }, {
            component: {
                attributes: {
                    numberOfRinses: WritableAttribute<LaundryWasherControls.NumberOfRinses, any>;
                    supportedRinses: Attribute<LaundryWasherControls.NumberOfRinses[], any>;
                };
            };
            flags: {
                rinse: true;
            };
        }];
        features: {
            rinse: BitFlag;
            spin: BitFlag;
        };
        id: 83;
        name: "LaundryWasherControls";
        revision: 1;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods