Expand description
interface MenuSwitchProps {
about?: string;
accept?: string;
accessKey?: string;
alt?: string;
"aria-activedescendant"?: string;
"aria-atomic"?: Booleanish;
"aria-autocomplete"?: "none" | "inline" | "list" | "both";
"aria-braillelabel"?: string;
"aria-brailleroledescription"?: string;
"aria-busy"?: Booleanish;
"aria-checked"?: boolean | "true" | "false" | "mixed";
"aria-colcount"?: number;
"aria-colindex"?: number;
"aria-colindextext"?: string;
"aria-colspan"?: number;
"aria-controls"?: string;
"aria-current"?:
| boolean
| "page"
| "time"
| "step"
| "true"
| "false"
| "location"
| "date";
"aria-describedby"?: string;
"aria-description"?: string;
"aria-details"?: string;
"aria-disabled"?: Booleanish;
"aria-dropeffect"?: "none"
| "copy"
| "move"
| "link"
| "execute"
| "popup";
"aria-errormessage"?: string;
"aria-expanded"?: Booleanish;
"aria-flowto"?: string;
"aria-grabbed"?: Booleanish;
"aria-haspopup"?:
| boolean
| "menu"
| "grid"
| "dialog"
| "true"
| "false"
| "listbox"
| "tree";
"aria-hidden"?: Booleanish;
"aria-invalid"?: boolean
| "true"
| "false"
| "grammar"
| "spelling";
"aria-keyshortcuts"?: string;
"aria-label"?: string;
"aria-labelledby"?: string;
"aria-level"?: number;
"aria-live"?: "off" | "assertive" | "polite";
"aria-modal"?: Booleanish;
"aria-multiline"?: Booleanish;
"aria-multiselectable"?: Booleanish;
"aria-orientation"?: "horizontal" | "vertical";
"aria-owns"?: string;
"aria-placeholder"?: string;
"aria-posinset"?: number;
"aria-pressed"?: boolean | "true" | "false" | "mixed";
"aria-readonly"?: Booleanish;
"aria-relevant"?:
| "all"
| "text"
| "additions"
| "additions removals"
| "additions text"
| "removals"
| "removals additions"
| "removals text"
| "text additions"
| "text removals";
"aria-required"?: Booleanish;
"aria-roledescription"?: string;
"aria-rowcount"?: number;
"aria-rowindex"?: number;
"aria-rowindextext"?: string;
"aria-rowspan"?: number;
"aria-selected"?: Booleanish;
"aria-setsize"?: number;
"aria-sort"?: "none"
| "other"
| "ascending"
| "descending";
"aria-valuemax"?: number;
"aria-valuemin"?: number;
"aria-valuenow"?: number;
"aria-valuetext"?: string;
as?: undefined;
autoCapitalize?:
| string & {}
| "none"
| "off"
| "on"
| "sentences"
| "words"
| "characters";
autoComplete?: HTMLInputAutoCompleteAttribute;
autoCorrect?: string;
autoFocus?: boolean;
autoSave?: string;
capture?: boolean
| "user"
| "environment";
checked?: boolean;
checkmark?:
| WithSlotShorthandValue<
{ as?: "span" } & Omit<
DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>,
"children",
> & { children?: any },
>
| null;
className?: string;
color?: string;
content?: string & (WithSlotShorthandValue<{ as?: "span" | undefined; } & Omit<DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "children"> & { ...; }> | null);
contentEditable?: "inherit" | Booleanish | "plaintext-only";
contextMenu?: string;
dangerouslySetInnerHTML?: { __html: string | TrustedHTML };
datatype?: string;
defaultChecked?: boolean;
defaultValue?: string | number | readonly string[];
dir?: string;
disabled?: boolean;
disabledFocusable?: boolean;
draggable?: Booleanish;
enterKeyHint?:
| "search"
| "enter"
| "done"
| "go"
| "next"
| "previous"
| "send";
exportparts?: string;
form?: string;
formAction?: string
| ((formData: FormData) => void | Promise<void>);
formEncType?: string;
formMethod?: string;
formNoValidate?: boolean;
formTarget?: string;
hasSubmenu?: boolean;
height?: string | number;
hidden?: boolean;
icon?:
| WithSlotShorthandValue<
{ as?: "span" } & Omit<
DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>,
"children",
> & { children?: any },
>
| null;
id?: string;
indicator?: NonNullable<
(
WithSlotShorthandValue<{ as?: "div" | undefined; } & Omit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "children"> & { ...; }> | null
),
>;
inert?: boolean;
inlist?: any;
input?: { as?: "input" } & Omit<
DetailedHTMLProps<
InputHTMLAttributes<HTMLInputElement>,
HTMLInputElement,
>,
"children",
> & { children?: undefined };
inputMode?:
| "none"
| "text"
| "search"
| "tel"
| "url"
| "email"
| "numeric"
| "decimal";
is?: string;
itemID?: string;
itemProp?: string;
itemRef?: string;
itemScope?: boolean;
itemType?: string;
key?: Key
| null;
label?:
| WithSlotShorthandValue<
Omit<ComponentProps<LabelSlots>, "required"> & {
disabled?: boolean;
required?: boolean | WithSlotShorthandValue<{ as?: "span" | undefined; } & Omit<DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "children"> & { ...; }> | null | undefined;
size?: "medium" | "small" | "large";
weight?: "regular" | "semibold";
} & RefAttributes<HTMLLabelElement>,
>
| null;
labelPosition?: "above" | "after" | "before";
lang?: string;
list?: string;
max?: string | number;
maxLength?: number;
min?: string | number;
minLength?: number;
multiple?: boolean;
name?: string;
nonce?: string;
onAbort?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onAbortCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onAnimationEnd?: AnimationEventHandler<HTMLInputElement> & AnimationEventHandler<
HTMLDivElement,
>;
onAnimationEndCapture?: AnimationEventHandler<HTMLInputElement> & AnimationEventHandler<
HTMLDivElement,
>;
onAnimationIteration?: AnimationEventHandler<HTMLInputElement> & AnimationEventHandler<
HTMLDivElement,
>;
onAnimationIterationCapture?: AnimationEventHandler<HTMLInputElement> & AnimationEventHandler<
HTMLDivElement,
>;
onAnimationStart?: AnimationEventHandler<HTMLInputElement> & AnimationEventHandler<
HTMLDivElement,
>;
onAnimationStartCapture?: AnimationEventHandler<HTMLInputElement> & AnimationEventHandler<
HTMLDivElement,
>;
onAuxClick?: MouseEventHandler<HTMLInputElement> & MouseEventHandler<
HTMLDivElement,
>;
onAuxClickCapture?: MouseEventHandler<HTMLInputElement> & MouseEventHandler<
HTMLDivElement,
>;
onBeforeInput?: InputEventHandler<HTMLInputElement> & InputEventHandler<
HTMLDivElement,
>;
onBeforeInputCapture?: InputEventHandler<HTMLInputElement> & InputEventHandler<
HTMLDivElement,
>;
onBeforeToggle?: ToggleEventHandler<HTMLInputElement> & ToggleEventHandler<
HTMLDivElement,
>;
onBlur?: FocusEventHandler<HTMLInputElement> & FocusEventHandler<
HTMLDivElement,
>;
onBlurCapture?: FocusEventHandler<HTMLInputElement> & FocusEventHandler<
HTMLDivElement,
>;
onCanPlay?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onCanPlayCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onCanPlayThrough?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onCanPlayThroughCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onChange: (
e:
| MouseEvent<HTMLDivElement, MouseEvent>
| ChangeEvent<HTMLInputElement, Element>,
data: SwitchOnChangeData,
) => void;
onChangeCapture?: ChangeEventHandler<HTMLInputElement, Element> & ChangeEventHandler<
HTMLDivElement,
Element,
>;
onClick?: MouseEventHandler<HTMLInputElement>;
onClickCapture?: MouseEventHandler<HTMLInputElement> & MouseEventHandler<
HTMLDivElement,
>;
onCompositionEnd?: CompositionEventHandler<HTMLInputElement> & CompositionEventHandler<
HTMLDivElement,
>;
onCompositionEndCapture?: CompositionEventHandler<HTMLInputElement> & CompositionEventHandler<
HTMLDivElement,
>;
onCompositionStart?: CompositionEventHandler<HTMLInputElement> & CompositionEventHandler<
HTMLDivElement,
>;
onCompositionStartCapture?: CompositionEventHandler<HTMLInputElement> & CompositionEventHandler<
HTMLDivElement,
>;
onCompositionUpdate?: CompositionEventHandler<HTMLInputElement> & CompositionEventHandler<
HTMLDivElement,
>;
onCompositionUpdateCapture?: CompositionEventHandler<HTMLInputElement> & CompositionEventHandler<
HTMLDivElement,
>;
onContextMenu?: MouseEventHandler<HTMLInputElement> & MouseEventHandler<
HTMLDivElement,
>;
onContextMenuCapture?: MouseEventHandler<HTMLInputElement> & MouseEventHandler<
HTMLDivElement,
>;
onCopy?: ClipboardEventHandler<HTMLInputElement> & ClipboardEventHandler<
HTMLDivElement,
>;
onCopyCapture?: ClipboardEventHandler<HTMLInputElement> & ClipboardEventHandler<
HTMLDivElement,
>;
onCut?: ClipboardEventHandler<HTMLInputElement> & ClipboardEventHandler<
HTMLDivElement,
>;
onCutCapture?: ClipboardEventHandler<HTMLInputElement> & ClipboardEventHandler<
HTMLDivElement,
>;
onDoubleClick?: MouseEventHandler<HTMLInputElement> & MouseEventHandler<
HTMLDivElement,
>;
onDoubleClickCapture?: MouseEventHandler<HTMLInputElement> & MouseEventHandler<
HTMLDivElement,
>;
onDrag?: DragEventHandler<HTMLInputElement> & DragEventHandler<
HTMLDivElement,
>;
onDragCapture?: DragEventHandler<HTMLInputElement> & DragEventHandler<
HTMLDivElement,
>;
onDragEnd?: DragEventHandler<HTMLInputElement> & DragEventHandler<
HTMLDivElement,
>;
onDragEndCapture?: DragEventHandler<HTMLInputElement> & DragEventHandler<
HTMLDivElement,
>;
onDragEnter?: DragEventHandler<HTMLInputElement> & DragEventHandler<
HTMLDivElement,
>;
onDragEnterCapture?: DragEventHandler<HTMLInputElement> & DragEventHandler<
HTMLDivElement,
>;
onDragExit?: DragEventHandler<HTMLInputElement> & DragEventHandler<
HTMLDivElement,
>;
onDragExitCapture?: DragEventHandler<HTMLInputElement> & DragEventHandler<
HTMLDivElement,
>;
onDragLeave?: DragEventHandler<HTMLInputElement> & DragEventHandler<
HTMLDivElement,
>;
onDragLeaveCapture?: DragEventHandler<HTMLInputElement> & DragEventHandler<
HTMLDivElement,
>;
onDragOver?: DragEventHandler<HTMLInputElement> & DragEventHandler<
HTMLDivElement,
>;
onDragOverCapture?: DragEventHandler<HTMLInputElement> & DragEventHandler<
HTMLDivElement,
>;
onDragStart?: DragEventHandler<HTMLInputElement> & DragEventHandler<
HTMLDivElement,
>;
onDragStartCapture?: DragEventHandler<HTMLInputElement> & DragEventHandler<
HTMLDivElement,
>;
onDrop?: DragEventHandler<HTMLInputElement> & DragEventHandler<
HTMLDivElement,
>;
onDropCapture?: DragEventHandler<HTMLInputElement> & DragEventHandler<
HTMLDivElement,
>;
onDurationChange?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onDurationChangeCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onEmptied?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onEmptiedCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onEncrypted?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onEncryptedCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onEnded?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onEndedCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onError?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onErrorCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onFocus?: FocusEventHandler<HTMLInputElement> & FocusEventHandler<
HTMLDivElement,
>;
onFocusCapture?: FocusEventHandler<HTMLInputElement> & FocusEventHandler<
HTMLDivElement,
>;
onGotPointerCapture?: PointerEventHandler<HTMLInputElement> & PointerEventHandler<
HTMLDivElement,
>;
onGotPointerCaptureCapture?: PointerEventHandler<HTMLInputElement> & PointerEventHandler<
HTMLDivElement,
>;
onInput?: InputEventHandler<HTMLInputElement> & InputEventHandler<
HTMLDivElement,
>;
onInputCapture?: InputEventHandler<HTMLInputElement> & InputEventHandler<
HTMLDivElement,
>;
onInvalid?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onInvalidCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onKeyDown?: KeyboardEventHandler<HTMLInputElement> & KeyboardEventHandler<
HTMLDivElement,
>;
onKeyDownCapture?: KeyboardEventHandler<HTMLInputElement> & KeyboardEventHandler<
HTMLDivElement,
>;
onKeyPress?: KeyboardEventHandler<HTMLInputElement> & KeyboardEventHandler<
HTMLDivElement,
>;
onKeyPressCapture?: KeyboardEventHandler<HTMLInputElement> & KeyboardEventHandler<
HTMLDivElement,
>;
onKeyUp?: KeyboardEventHandler<HTMLInputElement> & KeyboardEventHandler<
HTMLDivElement,
>;
onKeyUpCapture?: KeyboardEventHandler<HTMLInputElement> & KeyboardEventHandler<
HTMLDivElement,
>;
onLoad?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onLoadCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onLoadedData?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onLoadedDataCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onLoadedMetadata?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onLoadedMetadataCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onLoadStart?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onLoadStartCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onLostPointerCapture?: PointerEventHandler<HTMLInputElement> & PointerEventHandler<
HTMLDivElement,
>;
onLostPointerCaptureCapture?: PointerEventHandler<HTMLInputElement> & PointerEventHandler<
HTMLDivElement,
>;
onMouseDown?: MouseEventHandler<HTMLInputElement> & MouseEventHandler<
HTMLDivElement,
>;
onMouseDownCapture?: MouseEventHandler<HTMLInputElement> & MouseEventHandler<
HTMLDivElement,
>;
onMouseEnter?: MouseEventHandler<HTMLInputElement> & MouseEventHandler<
HTMLDivElement,
>;
onMouseLeave?: MouseEventHandler<HTMLInputElement> & MouseEventHandler<
HTMLDivElement,
>;
onMouseMove?: MouseEventHandler<HTMLInputElement> & MouseEventHandler<
HTMLDivElement,
>;
onMouseMoveCapture?: MouseEventHandler<HTMLInputElement> & MouseEventHandler<
HTMLDivElement,
>;
onMouseOut?: MouseEventHandler<HTMLInputElement> & MouseEventHandler<
HTMLDivElement,
>;
onMouseOutCapture?: MouseEventHandler<HTMLInputElement> & MouseEventHandler<
HTMLDivElement,
>;
onMouseOver?: MouseEventHandler<HTMLInputElement> & MouseEventHandler<
HTMLDivElement,
>;
onMouseOverCapture?: MouseEventHandler<HTMLInputElement> & MouseEventHandler<
HTMLDivElement,
>;
onMouseUp?: MouseEventHandler<HTMLInputElement> & MouseEventHandler<
HTMLDivElement,
>;
onMouseUpCapture?: MouseEventHandler<HTMLInputElement> & MouseEventHandler<
HTMLDivElement,
>;
onPaste?: ClipboardEventHandler<HTMLInputElement> & ClipboardEventHandler<
HTMLDivElement,
>;
onPasteCapture?: ClipboardEventHandler<HTMLInputElement> & ClipboardEventHandler<
HTMLDivElement,
>;
onPause?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onPauseCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onPlay?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onPlayCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onPlaying?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onPlayingCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onPointerCancel?: PointerEventHandler<HTMLInputElement> & PointerEventHandler<
HTMLDivElement,
>;
onPointerCancelCapture?: PointerEventHandler<HTMLInputElement> & PointerEventHandler<
HTMLDivElement,
>;
onPointerDown?: PointerEventHandler<HTMLInputElement> & PointerEventHandler<
HTMLDivElement,
>;
onPointerDownCapture?: PointerEventHandler<HTMLInputElement> & PointerEventHandler<
HTMLDivElement,
>;
onPointerEnter?: PointerEventHandler<HTMLInputElement> & PointerEventHandler<
HTMLDivElement,
>;
onPointerLeave?: PointerEventHandler<HTMLInputElement> & PointerEventHandler<
HTMLDivElement,
>;
onPointerMove?: PointerEventHandler<HTMLInputElement> & PointerEventHandler<
HTMLDivElement,
>;
onPointerMoveCapture?: PointerEventHandler<HTMLInputElement> & PointerEventHandler<
HTMLDivElement,
>;
onPointerOut?: PointerEventHandler<HTMLInputElement> & PointerEventHandler<
HTMLDivElement,
>;
onPointerOutCapture?: PointerEventHandler<HTMLInputElement> & PointerEventHandler<
HTMLDivElement,
>;
onPointerOver?: PointerEventHandler<HTMLInputElement> & PointerEventHandler<
HTMLDivElement,
>;
onPointerOverCapture?: PointerEventHandler<HTMLInputElement> & PointerEventHandler<
HTMLDivElement,
>;
onPointerUp?: PointerEventHandler<HTMLInputElement> & PointerEventHandler<
HTMLDivElement,
>;
onPointerUpCapture?: PointerEventHandler<HTMLInputElement> & PointerEventHandler<
HTMLDivElement,
>;
onProgress?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onProgressCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onRateChange?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onRateChangeCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onReset?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onResetCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onScroll?: UIEventHandler<HTMLInputElement> & UIEventHandler<
HTMLDivElement,
>;
onScrollCapture?: UIEventHandler<HTMLInputElement> & UIEventHandler<
HTMLDivElement,
>;
onScrollEnd?: UIEventHandler<HTMLInputElement> & UIEventHandler<
HTMLDivElement,
>;
onScrollEndCapture?: UIEventHandler<HTMLInputElement> & UIEventHandler<
HTMLDivElement,
>;
onSeeked?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onSeekedCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onSeeking?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onSeekingCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onSelect?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onSelectCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onStalled?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onStalledCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onSubmit?: SubmitEventHandler<HTMLInputElement> & SubmitEventHandler<
HTMLDivElement,
>;
onSubmitCapture?: SubmitEventHandler<HTMLInputElement> & SubmitEventHandler<
HTMLDivElement,
>;
onSuspend?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onSuspendCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onTimeUpdate?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onTimeUpdateCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onToggle?: ToggleEventHandler<HTMLInputElement> & ToggleEventHandler<
HTMLDivElement,
>;
onTouchCancel?: TouchEventHandler<HTMLInputElement> & TouchEventHandler<
HTMLDivElement,
>;
onTouchCancelCapture?: TouchEventHandler<HTMLInputElement> & TouchEventHandler<
HTMLDivElement,
>;
onTouchEnd?: TouchEventHandler<HTMLInputElement> & TouchEventHandler<
HTMLDivElement,
>;
onTouchEndCapture?: TouchEventHandler<HTMLInputElement> & TouchEventHandler<
HTMLDivElement,
>;
onTouchMove?: TouchEventHandler<HTMLInputElement> & TouchEventHandler<
HTMLDivElement,
>;
onTouchMoveCapture?: TouchEventHandler<HTMLInputElement> & TouchEventHandler<
HTMLDivElement,
>;
onTouchStart?: TouchEventHandler<HTMLInputElement> & TouchEventHandler<
HTMLDivElement,
>;
onTouchStartCapture?: TouchEventHandler<HTMLInputElement> & TouchEventHandler<
HTMLDivElement,
>;
onTransitionCancel?: TransitionEventHandler<HTMLInputElement> & TransitionEventHandler<
HTMLDivElement,
>;
onTransitionCancelCapture?: TransitionEventHandler<HTMLInputElement> & TransitionEventHandler<
HTMLDivElement,
>;
onTransitionEnd?: TransitionEventHandler<HTMLInputElement> & TransitionEventHandler<
HTMLDivElement,
>;
onTransitionEndCapture?: TransitionEventHandler<HTMLInputElement> & TransitionEventHandler<
HTMLDivElement,
>;
onTransitionRun?: TransitionEventHandler<HTMLInputElement> & TransitionEventHandler<
HTMLDivElement,
>;
onTransitionRunCapture?: TransitionEventHandler<HTMLInputElement> & TransitionEventHandler<
HTMLDivElement,
>;
onTransitionStart?: TransitionEventHandler<HTMLInputElement> & TransitionEventHandler<
HTMLDivElement,
>;
onTransitionStartCapture?: TransitionEventHandler<HTMLInputElement> & TransitionEventHandler<
HTMLDivElement,
>;
onVolumeChange?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onVolumeChangeCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onWaiting?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onWaitingCapture?: ReactEventHandler<HTMLInputElement> & ReactEventHandler<
HTMLDivElement,
>;
onWheel?: WheelEventHandler<HTMLInputElement> & WheelEventHandler<
HTMLDivElement,
>;
onWheelCapture?: WheelEventHandler<HTMLInputElement> & WheelEventHandler<
HTMLDivElement,
>;
part?: string;
pattern?: string;
persistOnClick?: boolean;
placeholder?: string;
popover?: ""
| "auto"
| "manual"
| "hint";
popoverTarget?: string;
popoverTargetAction?: "toggle" | "show" | "hide";
prefix?: string;
property?: string;
radioGroup?: string;
readOnly?: boolean;
rel?: string;
required?: boolean;
resource?: string;
results?: number;
rev?: string;
role?: AriaRole;
root?: NonNullable<
(
WithSlotShorthandValue<{ as?: "div" | undefined; } & Omit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "children"> & { ...; }> | null
),
>;
secondaryContent?: | WithSlotShorthandValue<
{ as?: "span" } & Omit<
DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>,
"children",
> & { children?: any },
>
| null;
security?: string;
size?: "medium" | "small";
slot?: string;
spellCheck?: Booleanish;
src?: string;
step?: string | number;
style?: CSSProperties;
submenuIndicator?:
| WithSlotShorthandValue<
{ as?: "span" } & Omit<
DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>,
"children",
> & { children?: any },
>
| null;
subText?:
| WithSlotShorthandValue<
{ as?: "span" } & Omit<
DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>,
"children",
> & { children?: any },
>
| null;
suppressContentEditableWarning?: boolean;
suppressHydrationWarning?: boolean;
tabIndex?: number;
title?: string;
translate?: "yes" | "no";
type?: HTMLInputTypeAttribute;
typeof?: string;
unselectable?: "off" | "on";
value?: string | number | readonly string[];
vocab?: string;
width?: string | number;
}Properties§
§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§
about?: string§accept?: string§access§alt?: string§ariaIdentifies the currently active element when DOM focus is on a composite widget, textbox, group, or application.
ariaIndicates whether assistive technologies will present all, or only parts of, the changed region based on the change notifications defined by the aria-relevant attribute.
ariaIndicates whether inputting text could trigger display of one or more predictions of the user's intended value for an input and specifies how predictions would be presented if they are made.
ariaDefines a string value that labels the current element, which is intended to be converted into Braille.
ariaDefines a human-readable, author-localized abbreviated description for the role of an element, which is intended to be converted into Braille.
aria§ariaIndicates the current "checked" state of checkboxes, radio buttons, and other widgets.
ariaDefines the total number of columns in a table, grid, or treegrid.
ariaDefines an element's column index or position with respect to the total number of columns within a table, grid, or treegrid.
ariaDefines a human readable text alternative of aria-colindex.
ariaDefines the number of columns spanned by a cell or gridcell within a table, grid, or treegrid.
ariaIdentifies the element (or elements) whose contents or presence are controlled by the current element.
ariaIndicates the element that represents the current item within a container or set of related elements.
ariaIdentifies the element (or elements) that describes the object.
ariaDefines a string value that describes or annotates the current element.
ariaIdentifies the element that provides a detailed, extended description for the object.
ariaIndicates that the element is perceivable but disabled, so it is not editable or otherwise operable.
ariaIndicates what functions can be performed when a dragged object is released on the drop target.
ariaIdentifies the element that provides an error message for the object.
ariaIndicates whether the element, or another grouping element it controls, is currently expanded or collapsed.
ariaIdentifies the next element (or elements) in an alternate reading order of content which, at the user's discretion, allows assistive technology to override the general default of reading in document source order.
ariaIndicates an element's "grabbed" state in a drag-and-drop operation.
ariaIndicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by an element.
Indicates whether the element is exposed to an accessibility API.
ariaIndicates the entered value does not conform to the format expected by the application.
ariaIndicates keyboard shortcuts that an author has implemented to activate or give focus to an element.
ariaDefines a string value that labels the current element.
ariaIdentifies the element (or elements) that labels the current element.
ariaDefines the hierarchical level of an element within a structure.
ariaIndicates that an element will be updated, and describes the types of updates the user agents, assistive technologies, and user can expect from the live region.
ariaIndicates whether an element is modal when displayed.
ariaIndicates whether a text box accepts multiple lines of input or only a single line.
ariaIndicates that the user may select more than one item from the current selectable descendants.
ariaIndicates whether the element's orientation is horizontal, vertical, or unknown/ambiguous.
ariaIdentifies an element (or elements) in order to define a visual, functional, or contextual parent/child relationship between DOM elements where the DOM hierarchy cannot be used to represent the relationship.
ariaDefines a short hint (a word or short phrase) intended to aid the user with data entry when the control has no value. A hint could be a sample value or a brief description of the expected format.
ariaDefines an element's number or position in the current set of listitems or treeitems. Not required if all elements in the set are present in the DOM.
ariaIndicates the current "pressed" state of toggle buttons.
ariaIndicates that the element is not editable, but is otherwise operable.
aria
| "all"
| "text"
| "additions"
| "additions removals"
| "additions text"
| "removals"
| "removals additions"
| "removals text"
| "text additions"
| "text removals"Indicates what notifications the user agent will trigger when the accessibility tree within a live region is modified.
ariaIndicates that user input is required on the element before a form may be submitted.
ariaDefines a human-readable, author-localized description for the role of an element.
ariaDefines the total number of rows in a table, grid, or treegrid.
ariaDefines an element's row index or position with respect to the total number of rows within a table, grid, or treegrid.
ariaDefines a human readable text alternative of aria-rowindex.
ariaDefines the number of rows spanned by a cell or gridcell within a table, grid, or treegrid.
ariaIndicates the current "selected" state of various widgets.
ariaDefines the number of items in the current set of listitems or treeitems. Not required if all elements in the set are present in the DOM.
ariaIndicates if items in a table or grid are sorted in ascending or descending order.
ariaDefines the maximum allowed value for a range widget.
ariaDefines the minimum allowed value for a range widget.
ariaDefines the current value for a range widget.
ariaDefines the human readable text alternative of aria-valuenow for a range widget.
as?: undefined§auto§auto§auto§auto§auto§capture?: boolean | "user" | "environment"§checked?: booleanDefines the controlled checked state of the Switch.
If passed, Switch ignores the defaultChecked property.
This should only be used if the checked state is to be controlled at a higher level and there is a plan to pass the
correct value based on handling onChange events and re-rendering.
checkmark?:
| WithSlotShorthandValue<
{ as?: "span" } & Omit<
DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>,
"children",
> & { children?: any },
>
| nullA helper slot for alignment when a menu item is used with selectable menuitems Avoid using this slot as a replacement for MenuItemCheckbox and MenuItemRadio components
class§color?: string§content?: string & (WithSlotShorthandValue<{ as?: "span" | undefined; } & Omit<DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "children"> & { ...; }> | null)Component children are placed in this slot
Avoid using the children property in this slot in favour of Component children whenever possible
content§dangerously§datatype?: string§defaultDefines whether the Switch is initially in a checked state or not when rendered.
default§dir?: string§disabled?: boolean§disabledWhen set, allows the Switch to be focusable even when it has been disabled. This is used in scenarios where it is important to keep a consistent tab order for screen reader and keyboard users.
draggable?: Booleanish§enter§exportparts?: string§
form?: string§form§form§form§form§formIf the menu item is a trigger for a submenu
height?: string | number§icon?:
| WithSlotShorthandValue<
{ as?: "span" } & Omit<
DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>,
"children",
> & { children?: any },
>
| nullIcon slot rendered before children content
id?: string§indicator?: NonNullable<
(
WithSlotShorthandValue<{ as?: "div" | undefined; } & Omit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "children"> & { ...; }> | null
),
>The track and the thumb sliding over it indicating the on and off status of the Switch.
inert?: boolean§
inlist?: any§input?: { as?: "input" } & Omit<
DetailedHTMLProps<
InputHTMLAttributes<HTMLInputElement>,
HTMLInputElement,
>,
"children",
> & { children?: undefined }Hidden input that handles the Switch's functionality.
This is the PRIMARY slot: all native properties specified directly on the <Switch> tag will be applied to this
slot, except className and style, which remain on the root slot.
inputHints at the type of data that might be entered by the user while editing the element or its contents
is?: stringSpecify that a standard HTML element should behave like a defined custom built-in element
item§item§item§item§item§key?: Key | null§label?:
| WithSlotShorthandValue<
Omit<ComponentProps<LabelSlots>, "required"> & {
disabled?: boolean;
required?: boolean | WithSlotShorthandValue<{ as?: "span" | undefined; } & Omit<DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "children"> & { ...; }> | null | undefined;
size?: "medium" | "small" | "large";
weight?: "regular" | "semibold";
} & RefAttributes<HTMLLabelElement>,
>
| nullThe Switch's label.
labelThe position of the label relative to the Switch.
lang?: string§list?: string§max?: string | number§max§min?: string | number§min§multiple?: boolean§name?: string§nonce?: string§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on
HTMLDivElement,
Element,
>§on§on§on
HTMLDivElement,
>§on
HTMLDivElement,
>§on
HTMLDivElement,
>§on
HTMLDivElement,
>§on
HTMLDivElement,
>§on
HTMLDivElement,
>§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§
on§
on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on§on
HTMLDivElement,
>§on
HTMLDivElement,
>§on
HTMLDivElement,
>§on
HTMLDivElement,
>§on
HTMLDivElement,
>§on
HTMLDivElement,
>§on
HTMLDivElement,
>§on
HTMLDivElement,
>§on§on§on§on§on§on§part?: string§
pattern?: string§persistClicking on the menu item will not dismiss an open menu
placeholder?: string§popover?: "" | "auto" | "manual" | "hint"§popover§popover§prefix?: string§property?: string§radio§read§rel?: string§required?: boolean§resource?: string§results?: number§rev?: string§role?: AriaRole§root?: NonNullable<
(
WithSlotShorthandValue<{ as?: "div" | undefined; } & Omit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "children"> & { ...; }> | null
),
>The root element of the Switch.
The root slot receives the className and style specified directly on the <Switch> tag.
All other native props will be applied to the primary slot: input.
secondary
| WithSlotShorthandValue<
{ as?: "span" } & Omit<
DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>,
"children",
> & { children?: any },
>
| nullSecondary content rendered opposite the primary content (e.g Shortcut text)
security?: string§size?: "medium" | "small"The size of the Switch.
slot?: string§spell§src?: string§step?: string | number§style?: CSSPropertiesIcon slot that shows the indicator for a submenu
sub
| WithSlotShorthandValue<
{ as?: "span" } & Omit<
DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>,
"children",
> & { children?: any },
>
| nullAdditional descriptor to main content that creates a multiline layout
suppress§suppress§tab§title?: string§translate?: "yes" | "no"§type?: HTMLInputTypeAttribute§typeof?: string§unselectable?: "off" | "on"§value?: string | number | readonly string[]§vocab?: string§width?: string | number
React component. A menu item with a label and a switch
This is a Wrapper around FUI MenuItem and Switch to display controlled switch menu item because the FUI MenuItemSwitch cannot be controlled individually from the menu
For now the label needs to be passed in as children
See Fluent UI Docs for Switch and Fluent UI Docs for MenuItem