Interface Complete

This cluster supports all Switch 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<{
        currentPosition: Attribute<number, any>;
        multiPressMax: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                momentarySwitchMultiPress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        numberOfPositions: FixedAttribute<number, any>;
    }, GlobalAttributes<{
        latchingSwitch: BitFlag;
        momentarySwitch: BitFlag;
        momentarySwitchLongPress: BitFlag;
        momentarySwitchMultiPress: BitFlag;
        momentarySwitchRelease: BitFlag;
    }>>;
    base: undefined;
    commands: {};
    events: {
        initialPress: Event<TypeFromFields<{
            newPosition: FieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                momentarySwitch: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        longPress: Event<TypeFromFields<{
            newPosition: FieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                momentarySwitchLongPress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        longRelease: Event<TypeFromFields<{
            previousPosition: FieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                momentarySwitchLongPress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        multiPressComplete: Event<TypeFromFields<{
            previousPosition: FieldType<number>;
            totalNumberOfPressesCounted: FieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                momentarySwitchMultiPress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        multiPressOngoing: Event<TypeFromFields<{
            currentNumberOfPressesCounted: FieldType<number>;
            newPosition: FieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                momentarySwitchMultiPress: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        shortRelease: Event<TypeFromFields<{
            previousPosition: FieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                momentarySwitchRelease: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        switchLatched: Event<TypeFromFields<{
            newPosition: FieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                latchingSwitch: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    extensions: undefined;
    features: {
        latchingSwitch: BitFlag;
        momentarySwitch: BitFlag;
        momentarySwitchLongPress: BitFlag;
        momentarySwitchMultiPress: BitFlag;
        momentarySwitchRelease: BitFlag;
    };
    id: Branded<59, "ClusterId">;
    name: "Switch";
    revision: 1;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            currentPosition: Attribute<number, any>;
            multiPressMax: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPositions: FixedAttribute<number, any>;
        };
        events: {
            initialPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressComplete: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
                totalNumberOfPressesCounted: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressOngoing: Event<TypeFromFields<{
                currentNumberOfPressesCounted: FieldType<number>;
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            shortRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchRelease: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            switchLatched: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    latchingSwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            latchingSwitch: BitFlag;
            momentarySwitch: BitFlag;
            momentarySwitchLongPress: BitFlag;
            momentarySwitchMultiPress: BitFlag;
            momentarySwitchRelease: BitFlag;
        };
        id: 59;
        name: "Switch";
        revision: 1;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            currentPosition: Attribute<number, any>;
            multiPressMax: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPositions: FixedAttribute<number, any>;
        };
        events: {
            initialPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressComplete: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
                totalNumberOfPressesCounted: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressOngoing: Event<TypeFromFields<{
                currentNumberOfPressesCounted: FieldType<number>;
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            shortRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchRelease: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            switchLatched: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    latchingSwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            latchingSwitch: BitFlag;
            momentarySwitch: BitFlag;
            momentarySwitchLongPress: BitFlag;
            momentarySwitchMultiPress: BitFlag;
            momentarySwitchRelease: BitFlag;
        };
        id: 59;
        name: "Switch";
        revision: 1;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            currentPosition: Attribute<number, any>;
            multiPressMax: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPositions: FixedAttribute<number, any>;
        };
        events: {
            initialPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressComplete: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
                totalNumberOfPressesCounted: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressOngoing: Event<TypeFromFields<{
                currentNumberOfPressesCounted: FieldType<number>;
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            shortRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchRelease: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            switchLatched: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    latchingSwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            latchingSwitch: BitFlag;
            momentarySwitch: BitFlag;
            momentarySwitchLongPress: BitFlag;
            momentarySwitchMultiPress: BitFlag;
            momentarySwitchRelease: BitFlag;
        };
        id: 59;
        name: "Switch";
        revision: 1;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            currentPosition: Attribute<number, any>;
            multiPressMax: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPositions: FixedAttribute<number, any>;
        };
        events: {
            initialPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressComplete: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
                totalNumberOfPressesCounted: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressOngoing: Event<TypeFromFields<{
                currentNumberOfPressesCounted: FieldType<number>;
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            shortRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchRelease: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            switchLatched: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    latchingSwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            latchingSwitch: BitFlag;
            momentarySwitch: BitFlag;
            momentarySwitchLongPress: BitFlag;
            momentarySwitchMultiPress: BitFlag;
            momentarySwitchRelease: BitFlag;
        };
        id: 59;
        name: "Switch";
        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<{
    currentPosition: Attribute<number, any>;
    multiPressMax: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            momentarySwitchMultiPress: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    numberOfPositions: FixedAttribute<number, any>;
}, GlobalAttributes<{
    latchingSwitch: BitFlag;
    momentarySwitch: BitFlag;
    momentarySwitchLongPress: BitFlag;
    momentarySwitchMultiPress: BitFlag;
    momentarySwitchRelease: BitFlag;
}>>

Type declaration

  • ReadonlycurrentPosition: Attribute<number, any>

    Indicates the position of the switch. The valid range is zero to NumberOfPositions-1. CurrentPosition value 0 shall be assigned to the default position of the switch: for example the "open" state of a rocker switch, or the "idle" state of a push button switch.

    See

    MatterSpecification.v13.Cluster § 1.13.5.2

  • ReadonlymultiPressMax: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            momentarySwitchMultiPress: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlynumberOfPositions: FixedAttribute<number, any>

    Indicates the maximum number of positions the switch has. Any kind of switch has a minimum of 2 positions. Also see Multi Position Details for the case NumberOfPositions>2.

    See

    MatterSpecification.v13.Cluster § 1.13.5.1

base

base: undefined

commands

commands: {}

events

events: {
    initialPress: Event<TypeFromFields<{
        newPosition: FieldType<number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            momentarySwitch: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    longPress: Event<TypeFromFields<{
        newPosition: FieldType<number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            momentarySwitchLongPress: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    longRelease: Event<TypeFromFields<{
        previousPosition: FieldType<number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            momentarySwitchLongPress: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    multiPressComplete: Event<TypeFromFields<{
        previousPosition: FieldType<number>;
        totalNumberOfPressesCounted: FieldType<number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            momentarySwitchMultiPress: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    multiPressOngoing: Event<TypeFromFields<{
        currentNumberOfPressesCounted: FieldType<number>;
        newPosition: FieldType<number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            momentarySwitchMultiPress: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    shortRelease: Event<TypeFromFields<{
        previousPosition: FieldType<number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            momentarySwitchRelease: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    switchLatched: Event<TypeFromFields<{
        newPosition: FieldType<number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            latchingSwitch: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}

extensions

extensions: undefined

features

features: {
    latchingSwitch: BitFlag;
    momentarySwitch: BitFlag;
    momentarySwitchLongPress: BitFlag;
    momentarySwitchMultiPress: BitFlag;
    momentarySwitchRelease: BitFlag;
}

Type declaration

  • ReadonlylatchingSwitch: BitFlag

    LatchingSwitch

    This feature is for a switch that maintains its position after being pressed (or turned).

    See

    MatterSpecification.v13.Cluster § 1.13.4.1

  • ReadonlymomentarySwitch: BitFlag

    MomentarySwitch

    This feature is for a switch that does not maintain its position after being pressed (or turned). After releasing, it goes back to its idle position.

    See

    MatterSpecification.v13.Cluster § 1.13.4.2

  • ReadonlymomentarySwitchLongPress: BitFlag

    MomentarySwitchLongPress

    This feature is for a momentary switch that can distinguish and report long presses from short presses. When this feature flag MSL is present, MS and MSR shall be present as well.

    See

    MatterSpecification.v13.Cluster § 1.13.4.4

  • ReadonlymomentarySwitchMultiPress: BitFlag

    MomentarySwitchMultiPress

    This feature is for a momentary switch that can distinguish and report double press and potentially multiple presses with more events, such as triple press, etc. When this feature flag MSM is present, MS and MSR shall be present as well.

    See

    MatterSpecification.v13.Cluster § 1.13.4.5

  • ReadonlymomentarySwitchRelease: BitFlag

    MomentarySwitchRelease

    This feature is for a momentary switch that can distinguish and report release events. When this feature flag MSR is present, MS shall be present as well.

    See

    MatterSpecification.v13.Cluster § 1.13.4.3

id

id: Branded<59, "ClusterId">

name

name

revision

revision

supportedFeatures

supportedFeatures: {}

unknown

unknown

Methods

alter

  • alter<const AlterationsT>(alterations): WithAlterations<Of<{
        attributes: {
            currentPosition: Attribute<number, any>;
            multiPressMax: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPositions: FixedAttribute<number, any>;
        };
        events: {
            initialPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressComplete: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
                totalNumberOfPressesCounted: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressOngoing: Event<TypeFromFields<{
                currentNumberOfPressesCounted: FieldType<number>;
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            shortRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchRelease: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            switchLatched: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    latchingSwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            latchingSwitch: BitFlag;
            momentarySwitch: BitFlag;
            momentarySwitchLongPress: BitFlag;
            momentarySwitchMultiPress: BitFlag;
            momentarySwitchRelease: BitFlag;
        };
        id: 59;
        name: "Switch";
        revision: 1;
    }>, AlterationsT>

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              currentPosition: Attribute<number, any>;
              multiPressMax: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitchMultiPress: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfPositions: FixedAttribute<number, any>;
          };
          events: {
              initialPress: Event<TypeFromFields<{
                  newPosition: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitch: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              longPress: Event<TypeFromFields<{
                  newPosition: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitchLongPress: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              longRelease: Event<TypeFromFields<{
                  previousPosition: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitchLongPress: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              multiPressComplete: Event<TypeFromFields<{
                  previousPosition: FieldType<number>;
                  totalNumberOfPressesCounted: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitchMultiPress: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              multiPressOngoing: Event<TypeFromFields<{
                  currentNumberOfPressesCounted: FieldType<number>;
                  newPosition: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitchMultiPress: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              shortRelease: Event<TypeFromFields<{
                  previousPosition: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitchRelease: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              switchLatched: Event<TypeFromFields<{
                  newPosition: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      latchingSwitch: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              latchingSwitch: BitFlag;
              momentarySwitch: BitFlag;
              momentarySwitchLongPress: BitFlag;
              momentarySwitchMultiPress: BitFlag;
              momentarySwitchRelease: BitFlag;
          };
          id: 59;
          name: "Switch";
          revision: 1;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            currentPosition: Attribute<number, any>;
            multiPressMax: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPositions: FixedAttribute<number, any>;
        };
        events: {
            initialPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressComplete: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
                totalNumberOfPressesCounted: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressOngoing: Event<TypeFromFields<{
                currentNumberOfPressesCounted: FieldType<number>;
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            shortRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchRelease: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            switchLatched: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    latchingSwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            latchingSwitch: BitFlag;
            momentarySwitch: BitFlag;
            momentarySwitchLongPress: BitFlag;
            momentarySwitchMultiPress: BitFlag;
            momentarySwitchRelease: BitFlag;
        };
        id: 59;
        name: "Switch";
        revision: 1;
    }>, AlterationsT>

enable

  • enable<const FlagsT>(flags): WithFlags<Of<{
        attributes: {
            currentPosition: Attribute<number, any>;
            multiPressMax: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPositions: FixedAttribute<number, any>;
        };
        events: {
            initialPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressComplete: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
                totalNumberOfPressesCounted: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressOngoing: Event<TypeFromFields<{
                currentNumberOfPressesCounted: FieldType<number>;
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            shortRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchRelease: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            switchLatched: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    latchingSwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            latchingSwitch: BitFlag;
            momentarySwitch: BitFlag;
            momentarySwitchLongPress: BitFlag;
            momentarySwitchMultiPress: BitFlag;
            momentarySwitchRelease: BitFlag;
        };
        id: 59;
        name: "Switch";
        revision: 1;
    }>, FlagsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              currentPosition: Attribute<number, any>;
              multiPressMax: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitchMultiPress: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfPositions: FixedAttribute<number, any>;
          };
          events: {
              initialPress: Event<TypeFromFields<{
                  newPosition: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitch: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              longPress: Event<TypeFromFields<{
                  newPosition: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitchLongPress: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              longRelease: Event<TypeFromFields<{
                  previousPosition: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitchLongPress: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              multiPressComplete: Event<TypeFromFields<{
                  previousPosition: FieldType<number>;
                  totalNumberOfPressesCounted: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitchMultiPress: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              multiPressOngoing: Event<TypeFromFields<{
                  currentNumberOfPressesCounted: FieldType<number>;
                  newPosition: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitchMultiPress: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              shortRelease: Event<TypeFromFields<{
                  previousPosition: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitchRelease: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              switchLatched: Event<TypeFromFields<{
                  newPosition: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      latchingSwitch: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              latchingSwitch: BitFlag;
              momentarySwitch: BitFlag;
              momentarySwitchLongPress: BitFlag;
              momentarySwitchMultiPress: BitFlag;
              momentarySwitchRelease: BitFlag;
          };
          id: 59;
          name: "Switch";
          revision: 1;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            currentPosition: Attribute<number, any>;
            multiPressMax: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPositions: FixedAttribute<number, any>;
        };
        events: {
            initialPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressComplete: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
                totalNumberOfPressesCounted: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressOngoing: Event<TypeFromFields<{
                currentNumberOfPressesCounted: FieldType<number>;
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            shortRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchRelease: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            switchLatched: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    latchingSwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            latchingSwitch: BitFlag;
            momentarySwitch: BitFlag;
            momentarySwitchLongPress: BitFlag;
            momentarySwitchMultiPress: BitFlag;
            momentarySwitchRelease: BitFlag;
        };
        id: 59;
        name: "Switch";
        revision: 1;
    }>, FlagsT>

set

  • set<const ValuesT>(values): WithValues<Of<{
        attributes: {
            currentPosition: Attribute<number, any>;
            multiPressMax: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPositions: FixedAttribute<number, any>;
        };
        events: {
            initialPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressComplete: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
                totalNumberOfPressesCounted: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressOngoing: Event<TypeFromFields<{
                currentNumberOfPressesCounted: FieldType<number>;
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            shortRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchRelease: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            switchLatched: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    latchingSwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            latchingSwitch: BitFlag;
            momentarySwitch: BitFlag;
            momentarySwitchLongPress: BitFlag;
            momentarySwitchMultiPress: BitFlag;
            momentarySwitchRelease: BitFlag;
        };
        id: 59;
        name: "Switch";
        revision: 1;
    }>, ValuesT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          currentPosition: number;
          multiPressMax?: number;
          numberOfPositions: number;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            currentPosition: Attribute<number, any>;
            multiPressMax: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPositions: FixedAttribute<number, any>;
        };
        events: {
            initialPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressComplete: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
                totalNumberOfPressesCounted: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressOngoing: Event<TypeFromFields<{
                currentNumberOfPressesCounted: FieldType<number>;
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            shortRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchRelease: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            switchLatched: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    latchingSwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            latchingSwitch: BitFlag;
            momentarySwitch: BitFlag;
            momentarySwitchLongPress: BitFlag;
            momentarySwitchMultiPress: BitFlag;
            momentarySwitchRelease: BitFlag;
        };
        id: 59;
        name: "Switch";
        revision: 1;
    }>, ValuesT>

with

  • with<const SelectionT>(...selection): Of<Of<{
        attributes: {
            currentPosition: Attribute<number, any>;
            multiPressMax: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPositions: FixedAttribute<number, any>;
        };
        events: {
            initialPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressComplete: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
                totalNumberOfPressesCounted: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressOngoing: Event<TypeFromFields<{
                currentNumberOfPressesCounted: FieldType<number>;
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            shortRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchRelease: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            switchLatched: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    latchingSwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            latchingSwitch: BitFlag;
            momentarySwitch: BitFlag;
            momentarySwitchLongPress: BitFlag;
            momentarySwitchMultiPress: BitFlag;
            momentarySwitchRelease: BitFlag;
        };
        id: 59;
        name: "Switch";
        revision: 1;
    }>, SelectionT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              currentPosition: Attribute<number, any>;
              multiPressMax: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitchMultiPress: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfPositions: FixedAttribute<number, any>;
          };
          events: {
              initialPress: Event<TypeFromFields<{
                  newPosition: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitch: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              longPress: Event<TypeFromFields<{
                  newPosition: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitchLongPress: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              longRelease: Event<TypeFromFields<{
                  previousPosition: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitchLongPress: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              multiPressComplete: Event<TypeFromFields<{
                  previousPosition: FieldType<number>;
                  totalNumberOfPressesCounted: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitchMultiPress: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              multiPressOngoing: Event<TypeFromFields<{
                  currentNumberOfPressesCounted: FieldType<number>;
                  newPosition: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitchMultiPress: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              shortRelease: Event<TypeFromFields<{
                  previousPosition: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      momentarySwitchRelease: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              switchLatched: Event<TypeFromFields<{
                  newPosition: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      latchingSwitch: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              latchingSwitch: BitFlag;
              momentarySwitch: BitFlag;
              momentarySwitchLongPress: BitFlag;
              momentarySwitchMultiPress: BitFlag;
              momentarySwitchRelease: BitFlag;
          };
          id: 59;
          name: "Switch";
          revision: 1;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            currentPosition: Attribute<number, any>;
            multiPressMax: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPositions: FixedAttribute<number, any>;
        };
        events: {
            initialPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longPress: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            longRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchLongPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressComplete: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
                totalNumberOfPressesCounted: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            multiPressOngoing: Event<TypeFromFields<{
                currentNumberOfPressesCounted: FieldType<number>;
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchMultiPress: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            shortRelease: Event<TypeFromFields<{
                previousPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    momentarySwitchRelease: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            switchLatched: Event<TypeFromFields<{
                newPosition: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    latchingSwitch: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            latchingSwitch: BitFlag;
            momentarySwitch: BitFlag;
            momentarySwitchLongPress: BitFlag;
            momentarySwitchMultiPress: BitFlag;
            momentarySwitchRelease: BitFlag;
        };
        id: 59;
        name: "Switch";
        revision: 1;
    }>, SelectionT>

Settings

Member Visibility

On This Page

Properties
Methods