Interface Complete

This cluster supports all MicrowaveOvenControl 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<{
        cookTime: Attribute<number, any>;
        maxCookTime: FixedAttribute<number, any>;
        maxPower: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                powerNumberLimits: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        minPower: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                powerNumberLimits: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        powerSetting: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                powerAsNumber: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        powerStep: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                powerNumberLimits: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        selectedWattIndex: Attribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                powerInWatts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        supportedWatts: FixedAttribute<number[], any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                powerInWatts: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        wattRating: OptionalFixedAttribute<number, any>;
    }, GlobalAttributes<{
        powerAsNumber: BitFlag;
        powerInWatts: BitFlag;
        powerNumberLimits: BitFlag;
    }>>;
    base: undefined;
    commands: {
        addMoreTime: OptionalCommand<TypeFromFields<{
            timeToAdd: FieldType<number>;
        }>, void, any>;
        setCookingParameters: Command<TypeFromFields<{
            cookMode: OptionalFieldType<number>;
            cookTime: OptionalFieldType<number>;
            powerSetting: OptionalFieldType<number>;
            startAfterSetting: OptionalFieldType<boolean>;
            wattSettingIndex: OptionalFieldType<number>;
        }>, void, any>;
    };
    events: {};
    extensions: undefined;
    features: {
        powerAsNumber: BitFlag;
        powerInWatts: BitFlag;
        powerNumberLimits: BitFlag;
    };
    id: Branded<95, "ClusterId">;
    name: "MicrowaveOvenControl";
    revision: 1;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            cookTime: Attribute<number, any>;
            maxCookTime: FixedAttribute<number, any>;
            maxPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerSetting: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAsNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerStep: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedWattIndex: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedWatts: FixedAttribute<number[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wattRating: OptionalFixedAttribute<number, any>;
        };
        commands: {
            addMoreTime: OptionalCommand<TypeFromFields<{
                timeToAdd: FieldType<number>;
            }>, void, any>;
            setCookingParameters: Command<TypeFromFields<{
                cookMode: OptionalFieldType<number>;
                cookTime: OptionalFieldType<number>;
                powerSetting: OptionalFieldType<number>;
                startAfterSetting: OptionalFieldType<boolean>;
                wattSettingIndex: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            powerAsNumber: BitFlag;
            powerInWatts: BitFlag;
            powerNumberLimits: BitFlag;
        };
        id: 95;
        name: "MicrowaveOvenControl";
        revision: 1;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            cookTime: Attribute<number, any>;
            maxCookTime: FixedAttribute<number, any>;
            maxPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerSetting: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAsNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerStep: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedWattIndex: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedWatts: FixedAttribute<number[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wattRating: OptionalFixedAttribute<number, any>;
        };
        commands: {
            addMoreTime: OptionalCommand<TypeFromFields<{
                timeToAdd: FieldType<number>;
            }>, void, any>;
            setCookingParameters: Command<TypeFromFields<{
                cookMode: OptionalFieldType<number>;
                cookTime: OptionalFieldType<number>;
                powerSetting: OptionalFieldType<number>;
                startAfterSetting: OptionalFieldType<boolean>;
                wattSettingIndex: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            powerAsNumber: BitFlag;
            powerInWatts: BitFlag;
            powerNumberLimits: BitFlag;
        };
        id: 95;
        name: "MicrowaveOvenControl";
        revision: 1;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            cookTime: Attribute<number, any>;
            maxCookTime: FixedAttribute<number, any>;
            maxPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerSetting: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAsNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerStep: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedWattIndex: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedWatts: FixedAttribute<number[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wattRating: OptionalFixedAttribute<number, any>;
        };
        commands: {
            addMoreTime: OptionalCommand<TypeFromFields<{
                timeToAdd: FieldType<number>;
            }>, void, any>;
            setCookingParameters: Command<TypeFromFields<{
                cookMode: OptionalFieldType<number>;
                cookTime: OptionalFieldType<number>;
                powerSetting: OptionalFieldType<number>;
                startAfterSetting: OptionalFieldType<boolean>;
                wattSettingIndex: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            powerAsNumber: BitFlag;
            powerInWatts: BitFlag;
            powerNumberLimits: BitFlag;
        };
        id: 95;
        name: "MicrowaveOvenControl";
        revision: 1;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            cookTime: Attribute<number, any>;
            maxCookTime: FixedAttribute<number, any>;
            maxPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerSetting: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAsNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerStep: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedWattIndex: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedWatts: FixedAttribute<number[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wattRating: OptionalFixedAttribute<number, any>;
        };
        commands: {
            addMoreTime: OptionalCommand<TypeFromFields<{
                timeToAdd: FieldType<number>;
            }>, void, any>;
            setCookingParameters: Command<TypeFromFields<{
                cookMode: OptionalFieldType<number>;
                cookTime: OptionalFieldType<number>;
                powerSetting: OptionalFieldType<number>;
                startAfterSetting: OptionalFieldType<boolean>;
                wattSettingIndex: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            powerAsNumber: BitFlag;
            powerInWatts: BitFlag;
            powerNumberLimits: BitFlag;
        };
        id: 95;
        name: "MicrowaveOvenControl";
        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: Merge<{
    cookTime: Attribute<number, any>;
    maxCookTime: FixedAttribute<number, any>;
    maxPower: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerNumberLimits: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    minPower: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerNumberLimits: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    powerSetting: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerAsNumber: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    powerStep: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerNumberLimits: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    selectedWattIndex: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerInWatts: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    supportedWatts: FixedAttribute<number[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerInWatts: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    wattRating: OptionalFixedAttribute<number, any>;
}, GlobalAttributes<{
    powerAsNumber: BitFlag;
    powerInWatts: BitFlag;
    powerNumberLimits: BitFlag;
}>>

Type declaration

  • ReadonlycookTime: Attribute<number, any>

    Indicates the total cook time associated with the operation of the device.

    This attribute shall remain unchanged during the operation of the oven unless the value is changed via a command or out-of-band action.

    See

    MatterSpecification.v13.Cluster § 8.13.5.1

  • ReadonlymaxCookTime: FixedAttribute<number, any>

    Indicates the maximum value to which the CookTime attribute can be set.

    See

    MatterSpecification.v13.Cluster § 8.13.5.2

  • ReadonlymaxPower: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerNumberLimits: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyminPower: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerNumberLimits: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlypowerSetting: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerAsNumber: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlypowerStep: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerNumberLimits: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyselectedWattIndex: Attribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerInWatts: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlysupportedWatts: FixedAttribute<number[], any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            powerInWatts: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlywattRating: OptionalFixedAttribute<number, any>

    Indicates the rating, in Watts, of the microwave power of the oven.

    Supporting this attribute can assist clients in suggesting cooking settings for various foods and beverages.

    See

    MatterSpecification.v13.Cluster § 8.13.5.9

base

base: undefined

commands

commands: {
    addMoreTime: OptionalCommand<TypeFromFields<{
        timeToAdd: FieldType<number>;
    }>, void, any>;
    setCookingParameters: Command<TypeFromFields<{
        cookMode: OptionalFieldType<number>;
        cookTime: OptionalFieldType<number>;
        powerSetting: OptionalFieldType<number>;
        startAfterSetting: OptionalFieldType<boolean>;
        wattSettingIndex: OptionalFieldType<number>;
    }>, void, any>;
}

Type declaration

  • ReadonlyaddMoreTime: OptionalCommand<TypeFromFields<{
        timeToAdd: FieldType<number>;
    }>, void, any>

    This command is used to add more time to the CookTime attribute of the server. This command supports these fields:

    See

    MatterSpecification.v13.Cluster § 8.13.6.3

  • ReadonlysetCookingParameters: Command<TypeFromFields<{
        cookMode: OptionalFieldType<number>;
        cookTime: OptionalFieldType<number>;
        powerSetting: OptionalFieldType<number>;
        startAfterSetting: OptionalFieldType<boolean>;
        wattSettingIndex: OptionalFieldType<number>;
    }>, void, any>

    This command is used to set the cooking parameters associated with the operation of the device.

    This command supports the following fields:

    See

    MatterSpecification.v13.Cluster § 8.13.6.2

events

events: {}

extensions

extensions: undefined

features

features: {
    powerAsNumber: BitFlag;
    powerInWatts: BitFlag;
    powerNumberLimits: BitFlag;
}

Type declaration

  • ReadonlypowerAsNumber: BitFlag

    PowerAsNumber

    Power is specified as a unitless number or a percentage

  • ReadonlypowerInWatts: BitFlag

    PowerInWatts

    Power is specified in Watts

  • ReadonlypowerNumberLimits: BitFlag

    PowerNumberLimits

    Supports the limit attributes used with the PWRNUM feature

id

id: Branded<95, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            cookTime: Attribute<number, any>;
            maxCookTime: FixedAttribute<number, any>;
            maxPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerSetting: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAsNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerStep: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedWattIndex: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedWatts: FixedAttribute<number[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wattRating: OptionalFixedAttribute<number, any>;
        };
        commands: {
            addMoreTime: OptionalCommand<TypeFromFields<{
                timeToAdd: FieldType<number>;
            }>, void, any>;
            setCookingParameters: Command<TypeFromFields<{
                cookMode: OptionalFieldType<number>;
                cookTime: OptionalFieldType<number>;
                powerSetting: OptionalFieldType<number>;
                startAfterSetting: OptionalFieldType<boolean>;
                wattSettingIndex: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            powerAsNumber: BitFlag;
            powerInWatts: BitFlag;
            powerNumberLimits: BitFlag;
        };
        id: 95;
        name: "MicrowaveOvenControl";
        revision: 1;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              cookTime: Attribute<number, any>;
              maxCookTime: FixedAttribute<number, any>;
              maxPower: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerNumberLimits: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minPower: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerNumberLimits: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              powerSetting: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAsNumber: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              powerStep: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerNumberLimits: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              selectedWattIndex: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerInWatts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supportedWatts: FixedAttribute<number[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerInWatts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              wattRating: OptionalFixedAttribute<number, any>;
          };
          commands: {
              addMoreTime: OptionalCommand<TypeFromFields<{
                  timeToAdd: FieldType<number>;
              }>, void, any>;
              setCookingParameters: Command<TypeFromFields<{
                  cookMode: OptionalFieldType<number>;
                  cookTime: OptionalFieldType<number>;
                  powerSetting: OptionalFieldType<number>;
                  startAfterSetting: OptionalFieldType<boolean>;
                  wattSettingIndex: OptionalFieldType<number>;
              }>, void, any>;
          };
          features: {
              powerAsNumber: BitFlag;
              powerInWatts: BitFlag;
              powerNumberLimits: BitFlag;
          };
          id: 95;
          name: "MicrowaveOvenControl";
          revision: 1;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            cookTime: Attribute<number, any>;
            maxCookTime: FixedAttribute<number, any>;
            maxPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerSetting: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAsNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerStep: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedWattIndex: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedWatts: FixedAttribute<number[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wattRating: OptionalFixedAttribute<number, any>;
        };
        commands: {
            addMoreTime: OptionalCommand<TypeFromFields<{
                timeToAdd: FieldType<number>;
            }>, void, any>;
            setCookingParameters: Command<TypeFromFields<{
                cookMode: OptionalFieldType<number>;
                cookTime: OptionalFieldType<number>;
                powerSetting: OptionalFieldType<number>;
                startAfterSetting: OptionalFieldType<boolean>;
                wattSettingIndex: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            powerAsNumber: BitFlag;
            powerInWatts: BitFlag;
            powerNumberLimits: BitFlag;
        };
        id: 95;
        name: "MicrowaveOvenControl";
        revision: 1;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            cookTime: Attribute<number, any>;
            maxCookTime: FixedAttribute<number, any>;
            maxPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerSetting: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAsNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerStep: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedWattIndex: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedWatts: FixedAttribute<number[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wattRating: OptionalFixedAttribute<number, any>;
        };
        commands: {
            addMoreTime: OptionalCommand<TypeFromFields<{
                timeToAdd: FieldType<number>;
            }>, void, any>;
            setCookingParameters: Command<TypeFromFields<{
                cookMode: OptionalFieldType<number>;
                cookTime: OptionalFieldType<number>;
                powerSetting: OptionalFieldType<number>;
                startAfterSetting: OptionalFieldType<boolean>;
                wattSettingIndex: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            powerAsNumber: BitFlag;
            powerInWatts: BitFlag;
            powerNumberLimits: BitFlag;
        };
        id: 95;
        name: "MicrowaveOvenControl";
        revision: 1;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              cookTime: Attribute<number, any>;
              maxCookTime: FixedAttribute<number, any>;
              maxPower: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerNumberLimits: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minPower: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerNumberLimits: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              powerSetting: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAsNumber: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              powerStep: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerNumberLimits: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              selectedWattIndex: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerInWatts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supportedWatts: FixedAttribute<number[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerInWatts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              wattRating: OptionalFixedAttribute<number, any>;
          };
          commands: {
              addMoreTime: OptionalCommand<TypeFromFields<{
                  timeToAdd: FieldType<number>;
              }>, void, any>;
              setCookingParameters: Command<TypeFromFields<{
                  cookMode: OptionalFieldType<number>;
                  cookTime: OptionalFieldType<number>;
                  powerSetting: OptionalFieldType<number>;
                  startAfterSetting: OptionalFieldType<boolean>;
                  wattSettingIndex: OptionalFieldType<number>;
              }>, void, any>;
          };
          features: {
              powerAsNumber: BitFlag;
              powerInWatts: BitFlag;
              powerNumberLimits: BitFlag;
          };
          id: 95;
          name: "MicrowaveOvenControl";
          revision: 1;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            cookTime: Attribute<number, any>;
            maxCookTime: FixedAttribute<number, any>;
            maxPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerSetting: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAsNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerStep: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedWattIndex: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedWatts: FixedAttribute<number[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wattRating: OptionalFixedAttribute<number, any>;
        };
        commands: {
            addMoreTime: OptionalCommand<TypeFromFields<{
                timeToAdd: FieldType<number>;
            }>, void, any>;
            setCookingParameters: Command<TypeFromFields<{
                cookMode: OptionalFieldType<number>;
                cookTime: OptionalFieldType<number>;
                powerSetting: OptionalFieldType<number>;
                startAfterSetting: OptionalFieldType<boolean>;
                wattSettingIndex: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            powerAsNumber: BitFlag;
            powerInWatts: BitFlag;
            powerNumberLimits: BitFlag;
        };
        id: 95;
        name: "MicrowaveOvenControl";
        revision: 1;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            cookTime: Attribute<number, any>;
            maxCookTime: FixedAttribute<number, any>;
            maxPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerSetting: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAsNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerStep: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedWattIndex: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedWatts: FixedAttribute<number[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wattRating: OptionalFixedAttribute<number, any>;
        };
        commands: {
            addMoreTime: OptionalCommand<TypeFromFields<{
                timeToAdd: FieldType<number>;
            }>, void, any>;
            setCookingParameters: Command<TypeFromFields<{
                cookMode: OptionalFieldType<number>;
                cookTime: OptionalFieldType<number>;
                powerSetting: OptionalFieldType<number>;
                startAfterSetting: OptionalFieldType<boolean>;
                wattSettingIndex: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            powerAsNumber: BitFlag;
            powerInWatts: BitFlag;
            powerNumberLimits: BitFlag;
        };
        id: 95;
        name: "MicrowaveOvenControl";
        revision: 1;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          cookTime: number;
          maxCookTime: number;
          maxPower?: number;
          minPower?: number;
          powerSetting?: number;
          powerStep?: number;
          selectedWattIndex?: number;
          supportedWatts?: number[];
          wattRating?: number;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            cookTime: Attribute<number, any>;
            maxCookTime: FixedAttribute<number, any>;
            maxPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerSetting: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAsNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerStep: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedWattIndex: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedWatts: FixedAttribute<number[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wattRating: OptionalFixedAttribute<number, any>;
        };
        commands: {
            addMoreTime: OptionalCommand<TypeFromFields<{
                timeToAdd: FieldType<number>;
            }>, void, any>;
            setCookingParameters: Command<TypeFromFields<{
                cookMode: OptionalFieldType<number>;
                cookTime: OptionalFieldType<number>;
                powerSetting: OptionalFieldType<number>;
                startAfterSetting: OptionalFieldType<boolean>;
                wattSettingIndex: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            powerAsNumber: BitFlag;
            powerInWatts: BitFlag;
            powerNumberLimits: BitFlag;
        };
        id: 95;
        name: "MicrowaveOvenControl";
        revision: 1;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            cookTime: Attribute<number, any>;
            maxCookTime: FixedAttribute<number, any>;
            maxPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerSetting: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAsNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerStep: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedWattIndex: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedWatts: FixedAttribute<number[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wattRating: OptionalFixedAttribute<number, any>;
        };
        commands: {
            addMoreTime: OptionalCommand<TypeFromFields<{
                timeToAdd: FieldType<number>;
            }>, void, any>;
            setCookingParameters: Command<TypeFromFields<{
                cookMode: OptionalFieldType<number>;
                cookTime: OptionalFieldType<number>;
                powerSetting: OptionalFieldType<number>;
                startAfterSetting: OptionalFieldType<boolean>;
                wattSettingIndex: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            powerAsNumber: BitFlag;
            powerInWatts: BitFlag;
            powerNumberLimits: BitFlag;
        };
        id: 95;
        name: "MicrowaveOvenControl";
        revision: 1;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              cookTime: Attribute<number, any>;
              maxCookTime: FixedAttribute<number, any>;
              maxPower: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerNumberLimits: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minPower: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerNumberLimits: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              powerSetting: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerAsNumber: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              powerStep: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerNumberLimits: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              selectedWattIndex: Attribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerInWatts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              supportedWatts: FixedAttribute<number[], any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      powerInWatts: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              wattRating: OptionalFixedAttribute<number, any>;
          };
          commands: {
              addMoreTime: OptionalCommand<TypeFromFields<{
                  timeToAdd: FieldType<number>;
              }>, void, any>;
              setCookingParameters: Command<TypeFromFields<{
                  cookMode: OptionalFieldType<number>;
                  cookTime: OptionalFieldType<number>;
                  powerSetting: OptionalFieldType<number>;
                  startAfterSetting: OptionalFieldType<boolean>;
                  wattSettingIndex: OptionalFieldType<number>;
              }>, void, any>;
          };
          features: {
              powerAsNumber: BitFlag;
              powerInWatts: BitFlag;
              powerNumberLimits: BitFlag;
          };
          id: 95;
          name: "MicrowaveOvenControl";
          revision: 1;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            cookTime: Attribute<number, any>;
            maxCookTime: FixedAttribute<number, any>;
            maxPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPower: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerSetting: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerAsNumber: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            powerStep: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerNumberLimits: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            selectedWattIndex: Attribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            supportedWatts: FixedAttribute<number[], any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    powerInWatts: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wattRating: OptionalFixedAttribute<number, any>;
        };
        commands: {
            addMoreTime: OptionalCommand<TypeFromFields<{
                timeToAdd: FieldType<number>;
            }>, void, any>;
            setCookingParameters: Command<TypeFromFields<{
                cookMode: OptionalFieldType<number>;
                cookTime: OptionalFieldType<number>;
                powerSetting: OptionalFieldType<number>;
                startAfterSetting: OptionalFieldType<boolean>;
                wattSettingIndex: OptionalFieldType<number>;
            }>, void, any>;
        };
        features: {
            powerAsNumber: BitFlag;
            powerInWatts: BitFlag;
            powerNumberLimits: BitFlag;
        };
        id: 95;
        name: "MicrowaveOvenControl";
        revision: 1;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods