@plasmicapp/react-web 0.2.384 → 0.2.387

package/dist/all.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
 import * as React$1 from 'react';
-import React__default, { AriaAttributes, DOMAttributes as DOMAttributes$1, AriaRole, CSSProperties as CSSProperties$1, ReactNode, ReactElement, FocusEvent, KeyboardEvent as KeyboardEvent$1, SyntheticEvent } from 'react';
+import React__default, { AriaAttributes, DOMAttributes as DOMAttributes$2, AriaRole, CSSProperties as CSSProperties$1, FocusEvent, KeyboardEvent as KeyboardEvent$3, SyntheticEvent, ReactNode, ReactElement } from 'react';
 
 declare global {
     interface Window {
@@ -12183,7 +12183,11 @@ type ControlContext<P> = [
     /**
      * props
      */
-    P
+    P,
+    /**
+     * context data
+     */
+    any
 ];
 /**
  * Config option that takes the context (e.g., props) of the function call
@@ -12356,6 +12360,18 @@ interface CustomFunctionMeta<F extends (...args: any[]) => any> {
      * not specified, it's considered `false`.
      */
     isDefaultExport?: boolean;
+    /**
+     * A function that takes the function arguments and returns a data key
+     * and a fetcher function.
+     * The data key is used to cache the result of the fetcher, and should only
+     * include the arguments that are used to fetch the data.
+     * The result of the fetcher will be used as the context of the function
+     * in studio and should return a promise.
+     */
+    fnContext?: (...args: Partial<Parameters<F>>) => {
+        dataKey: string;
+        fetcher: () => Promise<any>;
+    };
 }
 interface CustomFunctionRegistration {
     function: (...args: any[]) => any;
@@ -12934,7 +12950,189 @@ declare function Trans({ transKey, children }: TransProps): React__default.React
 
 
 
-interface AriaLabelingProps {
+/** Any focusable element, including both HTML and SVG elements. */
+interface FocusableElement$1 extends Element, HTMLOrSVGElement {}
+
+/** All DOM attributes supported across both HTML and SVG elements. */
+interface DOMAttributes$1<T = FocusableElement$1> extends AriaAttributes, DOMAttributes$2<T> {
+  id?: string | undefined,
+  role?: AriaRole | undefined,
+  tabIndex?: number | undefined,
+  style?: CSSProperties$1 | undefined,
+  className?: string | undefined
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+
+/** Any focusable element, including both HTML and SVG elements. */
+interface FocusableElement extends Element, HTMLOrSVGElement {}
+
+/** All DOM attributes supported across both HTML and SVG elements. */
+interface DOMAttributes<T = FocusableElement> extends AriaAttributes, DOMAttributes$2<T> {
+  id?: string | undefined,
+  role?: AriaRole | undefined,
+  tabIndex?: number | undefined,
+  style?: CSSProperties$1 | undefined,
+  className?: string | undefined
+}
+
+interface PressResult {
+    /** Whether the target is currently pressed. */
+    isPressed: boolean;
+    /** Props to spread on the target element. */
+    pressProps: DOMAttributes;
+}
+interface HoverResult {
+    /** Props to spread on the target element. */
+    hoverProps: DOMAttributes;
+    isHovered: boolean;
+}
+
+interface FocusRingAria {
+    /** Whether the element is currently focused. */
+    isFocused: boolean;
+    /** Whether keyboard focus should be visible. */
+    isFocusVisible: boolean;
+    /** Props to apply to the container element with the focus ring. */
+    focusProps: DOMAttributes$1;
+}
+
+type FocusHookResult = [boolean, FocusRingAria["focusProps"]];
+type HoverHookResult = [boolean, HoverResult["hoverProps"]];
+type PressHookResult = [boolean, PressResult["pressProps"]];
+declare function useFocused(opts: {
+    isTextInput?: boolean;
+}): FocusHookResult;
+declare function useFocusVisible(opts: {
+    isTextInput?: boolean;
+}): FocusHookResult;
+declare function useFocusedWithin(opts: {
+    isTextInput?: boolean;
+}): FocusHookResult;
+declare function useFocusVisibleWithin(opts: {
+    isTextInput?: boolean;
+}): FocusHookResult;
+declare function useHover(): HoverHookResult;
+declare function usePressed(): PressHookResult;
+declare const TRIGGER_TO_HOOK: {
+    readonly useHover: typeof useHover;
+    readonly useFocused: typeof useFocused;
+    readonly useFocusVisible: typeof useFocusVisible;
+    readonly useFocusedWithin: typeof useFocusedWithin;
+    readonly useFocusVisibleWithin: typeof useFocusVisibleWithin;
+    readonly usePressed: typeof usePressed;
+};
+type TriggerType = keyof typeof TRIGGER_TO_HOOK;
+interface TriggerOpts {
+    isTextInput?: boolean;
+}
+/**
+ * Installs argment trigger. All the useTrigger calls must use hardcoded `trigger` arg,
+ * as it's not valid to install variable React hooks!
+ */
+declare function useTrigger(trigger: TriggerType, opts: TriggerOpts): [boolean, React$1.HTMLAttributes<HTMLElement>];
+
+declare const classNames: any;
+
+declare function setPlumeStrictMode(mode: boolean): void;
+type VariantArgChoices<T> = T extends (infer M)[] ? M : T extends SingleChoiceArg<infer M> ? M : never;
+type VariantArgsChoices<V> = {
+    [k in keyof V]-?: VariantArgChoices<V[k]>;
+};
+type DictValues<V extends Record<string, any>> = V[keyof V];
+type DictTuples<V extends Record<string, any>> = DictValues<{
+    [K in keyof V]: [K, V[K]];
+}>;
+type VariantDefTuple<V> = DictTuples<VariantArgsChoices<V>>;
+type DistributeTuple<T> = T extends [infer T1, infer T2] ? {
+    group: T1;
+    variant: T2;
+} : never;
+type VariantDef<V> = DistributeTuple<VariantDefTuple<V>>;
+type PlasmicClass<V extends Record<string, any>, A extends Record<string, any>, O extends Record<string, any>> = {
+    (props: {
+        variants?: V;
+        args?: A;
+        overrides?: O;
+    }): React$1.ReactNode;
+    internalVariantProps: (keyof V)[];
+    internalArgProps: (keyof A)[];
+};
+type AnyPlasmicClass = PlasmicClass<any, any, any>;
+type PlasmicClassVariants<C extends AnyPlasmicClass> = C extends PlasmicClass<infer V, any, any> ? V : unknown;
+type PlasmicClassArgs<C extends AnyPlasmicClass> = C extends PlasmicClass<any, infer A, any> ? A : unknown;
+type PlasmicClassOverrides<C extends AnyPlasmicClass> = C extends PlasmicClass<any, any, infer O> ? O : unknown;
+
+interface PlumeCommonProps {
+    showStartIcon?: boolean;
+    showEndIcon?: boolean;
+    startIcon?: React$1.ReactNode;
+    endIcon?: React$1.ReactNode;
+    children?: React$1.ReactNode;
+    isDisabled?: boolean;
+}
+interface HtmlButtonProps extends Omit<React$1.ComponentProps<"button">, "ref" | "disabled"> {
+}
+interface HtmlAnchorProps extends Omit<React$1.ComponentProps<"a">, "ref" | "href" | "target"> {
+}
+interface PlumeActualButtonProps {
+    submitsForm?: boolean;
+}
+interface PlumeAnchorProps {
+    link?: string;
+    target?: React$1.ComponentProps<"a">["target"] | boolean;
+}
+type PlumeButtonProps = PlumeCommonProps & PlumeActualButtonProps & PlumeAnchorProps;
+type BaseButtonProps = PlumeButtonProps & HtmlButtonProps & HtmlAnchorProps;
+type AllButtonProps = PlumeCommonProps & PlumeActualButtonProps & HtmlButtonProps;
+type AllAnchorProps = PlumeCommonProps & PlumeAnchorProps & HtmlAnchorProps;
+type HtmlAnchorOnlyProps = Exclude<keyof AllAnchorProps, keyof AllButtonProps>;
+type HtmlButtonOnlyProps = Exclude<keyof AllButtonProps, keyof AllAnchorProps>;
+type ButtonRef = React$1.Ref<HTMLButtonElement | HTMLAnchorElement>;
+interface ButtonConfig<C extends AnyPlasmicClass> {
+    showStartIconVariant: VariantDef<PlasmicClassVariants<C>>;
+    showEndIconVariant?: VariantDef<PlasmicClassVariants<C>>;
+    isDisabledVariant?: VariantDef<PlasmicClassVariants<C>>;
+    startIconSlot?: keyof PlasmicClassArgs<C>;
+    endIconSlot?: keyof PlasmicClassArgs<C>;
+    contentSlot: keyof PlasmicClassArgs<C>;
+    root: keyof PlasmicClassOverrides<C>;
+}
+declare function useButton<P extends PlumeButtonProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: ButtonConfig<C>, ref?: ButtonRef): {
+    plasmicProps: {
+        variants: PlasmicClassVariants<C>;
+        args: PlasmicClassArgs<C>;
+        overrides: PlasmicClassOverrides<C>;
+    };
+};
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+
+interface AriaLabelingProps$2 {
   /**
    * Defines a string value that labels the current element.
    */
@@ -12966,14 +13164,14 @@ interface AriaValidationProps {
 
 // A set of common DOM props that are allowed on any component
 // Ensure this is synced with DOMPropNames in filterDOMProps
-interface DOMProps {
+interface DOMProps$2 {
   /**
    * The element's unique identifier. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/id).
    */
   id?: string
 }
 
-interface FocusableDOMProps extends DOMProps {
+interface FocusableDOMProps$2 extends DOMProps$2 {
   /**
    * Whether to exclude the element from the sequential tab order. If true,
    * the element will not be focusable via the keyboard by tabbing. This should
@@ -12983,25 +13181,13 @@ interface FocusableDOMProps extends DOMProps {
   excludeFromTabOrder?: boolean
 }
 
-interface InputDOMProps {
+interface InputDOMProps$1 {
   /**
    * The name of the input element, used when submitting an HTML form. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefname).
    */
   name?: string
 }
 
-/** Any focusable element, including both HTML and SVG elements. */
-interface FocusableElement extends Element, HTMLOrSVGElement {}
-
-/** All DOM attributes supported across both HTML and SVG elements. */
-interface DOMAttributes<T = FocusableElement> extends AriaAttributes, DOMAttributes$1<T> {
-  id?: string | undefined,
-  role?: AriaRole | undefined,
-  tabIndex?: number | undefined,
-  style?: CSSProperties$1 | undefined,
-  className?: string | undefined
-}
-
 /*
  * Copyright 2020 Adobe. All rights reserved.
  * This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -13043,7 +13229,7 @@ interface Validation<T = unknown> {
   validate?: (value: T) => ValidationError | true | null | undefined
 }
 
-interface InputBase {
+interface InputBase$2 {
   /** Whether the input is disabled. */
   isDisabled?: boolean,
   /** Whether the input can be selected but not changed by the user. */
@@ -13064,12 +13250,38 @@ interface InputBase {
 
 
 
-type SelectionMode = 'none' | 'single' | 'multiple';
-type SelectionBehavior = 'toggle' | 'replace';
-type Selection = 'all' | Set<Key>;
+// Event bubbling can be problematic in real-world applications, so the default for React Spectrum components
+// is not to propagate. This can be overridden by calling continuePropagation() on the event.
+type BaseEvent$2<T extends SyntheticEvent> = T & {
+  /**
+   * Use continuePropagation.
+   * @deprecated */
+  stopPropagation(): void,
+  continuePropagation(): void
+}
 
-type FocusStrategy = 'first' | 'last';
-type DisabledBehavior = 'selection' | 'all';
+type KeyboardEvent$2 = BaseEvent$2<KeyboardEvent$3<any>>;
+
+interface KeyboardEvents$2 {
+  /** Handler that is called when a key is pressed. */
+  onKeyDown?: (e: KeyboardEvent$2) => void,
+  /** Handler that is called when a key is released. */
+  onKeyUp?: (e: KeyboardEvent$2) => void
+}
+
+interface FocusEvents$2<Target = Element> {
+  /** Handler that is called when the element receives focus. */
+  onFocus?: (e: FocusEvent<Target>) => void,
+  /** Handler that is called when the element loses focus. */
+  onBlur?: (e: FocusEvent<Target>) => void,
+  /** Handler that is called when the element's focus status changes. */
+  onFocusChange?: (isFocused: boolean) => void
+}
+
+interface FocusableProps$2<Target = Element> extends FocusEvents$2<Target>, KeyboardEvents$2 {
+  /** Whether the element should receive focus on render. */
+  autoFocus?: boolean
+}
 
 /*
  * Copyright 2020 Adobe. All rights reserved.
@@ -13085,79 +13297,97 @@ type DisabledBehavior = 'selection' | 'all';
 
 
 
-/**
- * A generic interface to access a readonly sequential
- * collection of unique keyed items.
- */
-interface Collection<T> extends Iterable<T> {
-  /** The number of items in the collection. */
-  readonly size: number,
+interface ToggleStateOptions extends InputBase$2 {
+  /**
+   * Whether the element should be selected (uncontrolled).
+   */
+  defaultSelected?: boolean,
+  /**
+   * Whether the element should be selected (controlled).
+   */
+  isSelected?: boolean,
+  /**
+   * Handler that is called when the element's selection state changes.
+   */
+  onChange?: (isSelected: boolean) => void
+}
 
-  /** Iterate over all keys in the collection. */
-  getKeys(): Iterable<Key>,
+interface ToggleProps extends ToggleStateOptions, Validation<boolean>, FocusableProps$2 {
+  /**
+   * The label for the element.
+   */
+  children?: ReactNode,
+  /**
+   * The value of the input element, used when submitting an HTML form. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefvalue).
+   */
+  value?: string
+}
 
-  /** Get an item by its key. */
-  getItem(key: Key): T | null,
+interface AriaToggleProps extends ToggleProps, FocusableDOMProps$2, AriaLabelingProps$2, AriaValidationProps, InputDOMProps$1 {
+  /**
+   * Identifies the element (or elements) whose contents or presence are controlled by the current element.
+   */
+  'aria-controls'?: string
+}
 
-  /** Get an item by the index of its key. */
-  at(idx: number): T | null,
+interface CheckboxProps$1 extends ToggleProps {
+  /**
+   * Indeterminism is presentational only.
+   * The indeterminate visual representation remains regardless of user interaction.
+   */
+  isIndeterminate?: boolean
+}
 
-  /** Get the key that comes before the given key in the collection. */
-  getKeyBefore(key: Key): Key | null,
+interface AriaCheckboxProps extends CheckboxProps$1, AriaToggleProps {}
 
-  /** Get the key that comes after the given key in the collection. */
-  getKeyAfter(key: Key): Key | null,
-
-  /** Get the first key in the collection. */
-  getFirstKey(): Key | null,
-
-  /** Get the last key in the collection. */
-  getLastKey(): Key | null,
-
-  /** Iterate over the child items of the given key. */
-  getChildren?(key: Key): Iterable<T>,
-
-  /** Returns a string representation of the item's contents. */
-  getTextValue?(key: Key): string
+interface StyleProps {
+    className?: string;
+    style?: React$1.CSSProperties;
 }
+declare function getDataProps(props: Record<string, any>): Partial<Record<string, any>>;
 
-interface Node<T> {
-  /** The type of item this node represents. */
-  type: string,
-  /** A unique key for the node. */
-  key: Key,
-  /** The object value the node was created from. */
-  value: T | null,
-  /** The level of depth this node is at in the hierarchy. */
-  level: number,
-  /** Whether this item has children, even if not loaded yet. */
-  hasChildNodes: boolean,
-  /**
-   * The loaded children of this node.
-   * @deprecated Use `collection.getChildren(node.key)` instead.
-   */
-  childNodes: Iterable<Node<T>>,
-  /** The rendered contents of this node (e.g. JSX). */
-  rendered: ReactNode,
-  /** A string value for this node, used for features like typeahead. */
-  textValue: string,
-  /** An accessibility label for this node. */
-  'aria-label'?: string,
-  /** The index of this node within its parent. */
-  index?: number,
-  /** A function that should be called to wrap the rendered node. */
-  wrapper?: (element: ReactElement) => ReactElement,
-  /** The key of the parent node. */
-  parentKey?: Key | null,
-  /** The key of the node before this node. */
-  prevKey?: Key | null,
-  /** The key of the node after this node. */
-  nextKey?: Key | null,
-  /** Additional properties specific to a particular node type. */
-  props?: any,
-  /** @private */
-  shouldInvalidate?: (context: unknown) => boolean
+type CheckboxRef = React$1.Ref<CheckboxRefValue>;
+interface CheckboxRefValue extends CheckboxState {
+    getRoot: () => HTMLElement | null;
+    focus: () => void;
+    blur: () => void;
+}
+interface CheckboxState {
+    setChecked: (checked: boolean) => void;
+}
+interface CheckboxProps extends Omit<AriaCheckboxProps, "isSelected" | "defaultSelected">, StyleProps {
+    /**
+     * Whether the Checkbox is checked or not; controlled
+     */
+    isChecked?: boolean;
+    /**
+     * Whether the Checkbox is checked by default; uncontrolled
+     */
+    defaultChecked?: boolean;
+    /**
+     * Whether the Checkbox is in an "indeterminate" state; this usually
+     * refers to a "check all" that is used to check / uncheck many other
+     * checkboxes, and is visually indeterminate if some of its controlled
+     * checkboxes are checked and some are not.
+     */
+    isIndeterminate?: boolean;
+}
+interface CheckboxConfig<C extends AnyPlasmicClass> {
+    isCheckedVariant: VariantDef<PlasmicClassVariants<C>>;
+    isIndeterminateVariant?: VariantDef<PlasmicClassVariants<C>>;
+    isDisabledVariant?: VariantDef<PlasmicClassVariants<C>>;
+    noLabelVariant?: VariantDef<PlasmicClassVariants<C>>;
+    labelSlot?: keyof PlasmicClassArgs<C>;
+    root: keyof PlasmicClassOverrides<C>;
 }
+declare function useCheckbox<P extends CheckboxProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: CheckboxConfig<C>, ref?: CheckboxRef): {
+    plasmicProps: {
+        variants: PlasmicClassVariants<C>;
+        overrides: PlasmicClassOverrides<C>;
+        args: PlasmicClassArgs<C>;
+    };
+    state: CheckboxState;
+};
 
 /*
  * Copyright 2020 Adobe. All rights reserved.
@@ -13173,71 +13403,49 @@ interface Node<T> {
 
 
 
-// Event bubbling can be problematic in real-world applications, so the default for React Spectrum components
-// is not to propagate. This can be overridden by calling continuePropagation() on the event.
-type BaseEvent<T extends SyntheticEvent> = T & {
+interface AriaLabelingProps$1 {
   /**
-   * Use continuePropagation.
-   * @deprecated */
-  stopPropagation(): void,
-  continuePropagation(): void
-}
-
-type KeyboardEvent = BaseEvent<KeyboardEvent$1<any>>;
-
-type PointerType = 'mouse' | 'pen' | 'touch' | 'keyboard' | 'virtual';
+   * Defines a string value that labels the current element.
+   */
+  'aria-label'?: string,
 
-interface PressEvent {
-  /** The type of press event being fired. */
-  type: 'pressstart' | 'pressend' | 'pressup' | 'press',
-  /** The pointer type that triggered the press event. */
-  pointerType: PointerType,
-  /** The target element of the press event. */
-  target: Element,
-  /** Whether the shift keyboard modifier was held during the press event. */
-  shiftKey: boolean,
-  /** Whether the ctrl keyboard modifier was held during the press event. */
-  ctrlKey: boolean,
-  /** Whether the meta keyboard modifier was held during the press event. */
-  metaKey: boolean,
-  /** Whether the alt keyboard modifier was held during the press event. */
-  altKey: boolean,
   /**
-   * By default, press events stop propagation to parent elements.
-   * In cases where a handler decides not to handle a specific event,
-   * it can call `continuePropagation()` to allow a parent to handle it.
+   * Identifies the element (or elements) that labels the current element.
    */
-  continuePropagation(): void
-}
+  'aria-labelledby'?: string,
 
-interface LongPressEvent extends Omit<PressEvent, 'type' | 'continuePropagation'> {
-  /** The type of long press event being fired. */
-  type: 'longpressstart' | 'longpressend' | 'longpress'
-}
+  /**
+   * Identifies the element (or elements) that describes the object.
+   */
+  'aria-describedby'?: string,
 
-interface KeyboardEvents {
-  /** Handler that is called when a key is pressed. */
-  onKeyDown?: (e: KeyboardEvent) => void,
-  /** Handler that is called when a key is released. */
-  onKeyUp?: (e: KeyboardEvent) => void
+  /**
+   * Identifies the element (or elements) that provide a detailed, extended description for the object.
+   */
+  'aria-details'?: string
 }
 
-interface FocusEvents<Target = Element> {
-  /** Handler that is called when the element receives focus. */
-  onFocus?: (e: FocusEvent<Target>) => void,
-  /** Handler that is called when the element loses focus. */
-  onBlur?: (e: FocusEvent<Target>) => void,
-  /** Handler that is called when the element's focus status changes. */
-  onFocusChange?: (isFocused: boolean) => void
+// A set of common DOM props that are allowed on any component
+// Ensure this is synced with DOMPropNames in filterDOMProps
+interface DOMProps$1 {
+  /**
+   * The element's unique identifier. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/id).
+   */
+  id?: string
 }
 
-interface FocusableProps<Target = Element> extends FocusEvents<Target>, KeyboardEvents {
-  /** Whether the element should receive focus on render. */
-  autoFocus?: boolean
+interface FocusableDOMProps$1 extends DOMProps$1 {
+  /**
+   * Whether to exclude the element from the sequential tab order. If true,
+   * the element will not be focusable via the keyboard by tabbing. This should
+   * be avoided except in rare scenarios where an alternative means of accessing
+   * the element or its functionality via the keyboard is available.
+   */
+  excludeFromTabOrder?: boolean
 }
 
 /*
- * Copyright 2023 Adobe. All rights reserved.
+ * Copyright 2020 Adobe. All rights reserved.
  * This file is licensed to you under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License. You may obtain a copy
  * of the License at http://www.apache.org/licenses/LICENSE-2.0
@@ -13248,119 +13456,30 @@ interface FocusableProps<Target = Element> extends FocusEvents<Target>, Keyboard
  * governing permissions and limitations under the License.
  */
 
-type Key = string | number;
 
-declare function useFocused(opts: {
-    isTextInput?: boolean;
-}): (boolean | DOMAttributes<FocusableElement>)[];
-declare function useFocusVisible(opts: {
-    isTextInput?: boolean;
-}): (boolean | DOMAttributes<FocusableElement>)[];
-declare function useFocusedWithin(opts: {
-    isTextInput?: boolean;
-}): (boolean | DOMAttributes<FocusableElement>)[];
-declare function useFocusVisibleWithin(opts: {
-    isTextInput?: boolean;
-}): (boolean | DOMAttributes<FocusableElement>)[];
-declare function useHover(): (boolean | {
-    onMouseEnter: () => void;
-    onMouseLeave: () => void;
-})[];
-declare function usePressed(): (boolean | {
-    onMouseDown: () => void;
-    onMouseUp: () => void;
-})[];
-declare const TRIGGER_TO_HOOK: {
-    readonly useHover: typeof useHover;
-    readonly useFocused: typeof useFocused;
-    readonly useFocusVisible: typeof useFocusVisible;
-    readonly useFocusedWithin: typeof useFocusedWithin;
-    readonly useFocusVisibleWithin: typeof useFocusVisibleWithin;
-    readonly usePressed: typeof usePressed;
-};
-type TriggerType = keyof typeof TRIGGER_TO_HOOK;
-interface TriggerOpts {
-    isTextInput?: boolean;
+
+interface InputBase$1 {
+  /** Whether the input is disabled. */
+  isDisabled?: boolean,
+  /** Whether the input can be selected but not changed by the user. */
+  isReadOnly?: boolean
 }
-/**
- * Installs argment trigger. All the useTrigger calls must use hardcoded `trigger` arg,
- * as it's not valid to install variable React hooks!
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
  */
-declare function useTrigger(trigger: TriggerType, opts: TriggerOpts): [boolean, React$1.HTMLAttributes<HTMLElement>];
 
-declare const classNames: any;
 
-declare function setPlumeStrictMode(mode: boolean): void;
-type VariantArgChoices<T> = T extends (infer M)[] ? M : T extends SingleChoiceArg<infer M> ? M : never;
-type VariantArgsChoices<V> = {
-    [k in keyof V]-?: VariantArgChoices<V[k]>;
-};
-type DictValues<V extends Record<string, any>> = V[keyof V];
-type DictTuples<V extends Record<string, any>> = DictValues<{
-    [K in keyof V]: [K, V[K]];
-}>;
-type VariantDefTuple<V> = DictTuples<VariantArgsChoices<V>>;
-type DistributeTuple<T> = T extends [infer T1, infer T2] ? {
-    group: T1;
-    variant: T2;
-} : never;
-type VariantDef<V> = DistributeTuple<VariantDefTuple<V>>;
-type PlasmicClass<V extends Record<string, any>, A extends Record<string, any>, O extends Record<string, any>> = {
-    (props: {
-        variants?: V;
-        args?: A;
-        overrides?: O;
-    }): React$1.ReactNode;
-    internalVariantProps: (keyof V)[];
-    internalArgProps: (keyof A)[];
-};
-type AnyPlasmicClass = PlasmicClass<any, any, any>;
-type PlasmicClassVariants<C extends AnyPlasmicClass> = C extends PlasmicClass<infer V, any, any> ? V : unknown;
-type PlasmicClassArgs<C extends AnyPlasmicClass> = C extends PlasmicClass<any, infer A, any> ? A : unknown;
-type PlasmicClassOverrides<C extends AnyPlasmicClass> = C extends PlasmicClass<any, any, infer O> ? O : unknown;
 
-interface PlumeCommonProps {
-    showStartIcon?: boolean;
-    showEndIcon?: boolean;
-    startIcon?: React$1.ReactNode;
-    endIcon?: React$1.ReactNode;
-    children?: React$1.ReactNode;
-    isDisabled?: boolean;
-}
-interface HtmlButtonProps extends Omit<React$1.ComponentProps<"button">, "ref" | "disabled"> {
-}
-interface HtmlAnchorProps extends Omit<React$1.ComponentProps<"a">, "ref" | "href" | "target"> {
-}
-interface PlumeActualButtonProps {
-    submitsForm?: boolean;
-}
-interface PlumeAnchorProps {
-    link?: string;
-    target?: React$1.ComponentProps<"a">["target"] | boolean;
-}
-type PlumeButtonProps = PlumeCommonProps & PlumeActualButtonProps & PlumeAnchorProps;
-type BaseButtonProps = PlumeButtonProps & HtmlButtonProps & HtmlAnchorProps;
-type AllButtonProps = PlumeCommonProps & PlumeActualButtonProps & HtmlButtonProps;
-type AllAnchorProps = PlumeCommonProps & PlumeAnchorProps & HtmlAnchorProps;
-type HtmlAnchorOnlyProps = Exclude<keyof AllAnchorProps, keyof AllButtonProps>;
-type HtmlButtonOnlyProps = Exclude<keyof AllButtonProps, keyof AllAnchorProps>;
-type ButtonRef = React$1.Ref<HTMLButtonElement | HTMLAnchorElement>;
-interface ButtonConfig<C extends AnyPlasmicClass> {
-    showStartIconVariant: VariantDef<PlasmicClassVariants<C>>;
-    showEndIconVariant?: VariantDef<PlasmicClassVariants<C>>;
-    isDisabledVariant?: VariantDef<PlasmicClassVariants<C>>;
-    startIconSlot?: keyof PlasmicClassArgs<C>;
-    endIconSlot?: keyof PlasmicClassArgs<C>;
-    contentSlot: keyof PlasmicClassArgs<C>;
-    root: keyof PlasmicClassOverrides<C>;
-}
-declare function useButton<P extends PlumeButtonProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: ButtonConfig<C>, ref?: ButtonRef): {
-    plasmicProps: {
-        variants: PlasmicClassVariants<C>;
-        args: PlasmicClassArgs<C>;
-        overrides: PlasmicClassOverrides<C>;
-    };
-};
+type FocusStrategy$1 = 'first' | 'last';
 
 /*
  * Copyright 2020 Adobe. All rights reserved.
@@ -13376,96 +13495,40 @@ declare function useButton<P extends PlumeButtonProps, C extends AnyPlasmicClass
 
 
 
-interface ToggleProps extends InputBase, Validation<boolean>, FocusableProps {
-  /**
-   * The label for the element.
-   */
-  children?: ReactNode,
-  /**
-   * Whether the element should be selected (uncontrolled).
-   */
-  defaultSelected?: boolean,
-  /**
-   * Whether the element should be selected (controlled).
-   */
-  isSelected?: boolean,
-  /**
-   * Handler that is called when the element's selection state changes.
-   */
-  onChange?: (isSelected: boolean) => void,
-  /**
-   * The value of the input element, used when submitting an HTML form. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefvalue).
-   */
-  value?: string
-}
-
-interface AriaToggleProps extends ToggleProps, FocusableDOMProps, AriaLabelingProps, AriaValidationProps, InputDOMProps {
-  /**
-   * Identifies the element (or elements) whose contents or presence are controlled by the current element.
-   */
-  'aria-controls'?: string
-}
-
-interface CheckboxProps$1 extends ToggleProps {
-  /**
-   * Indeterminism is presentational only.
-   * The indeterminate visual representation remains regardless of user interaction.
-   */
-  isIndeterminate?: boolean
+// Event bubbling can be problematic in real-world applications, so the default for React Spectrum components
+// is not to propagate. This can be overridden by calling continuePropagation() on the event.
+type BaseEvent$1<T extends SyntheticEvent> = T & {
+  /**
+   * Use continuePropagation.
+   * @deprecated */
+  stopPropagation(): void,
+  continuePropagation(): void
 }
 
-interface AriaCheckboxProps extends CheckboxProps$1, AriaToggleProps {}
+type KeyboardEvent$1 = BaseEvent$1<KeyboardEvent$3<any>>;
 
-interface StyleProps {
-    className?: string;
-    style?: React$1.CSSProperties;
+interface KeyboardEvents$1 {
+  /** Handler that is called when a key is pressed. */
+  onKeyDown?: (e: KeyboardEvent$1) => void,
+  /** Handler that is called when a key is released. */
+  onKeyUp?: (e: KeyboardEvent$1) => void
 }
-declare function getDataProps(props: Record<string, any>): Partial<Record<string, any>>;
 
-type CheckboxRef = React$1.Ref<CheckboxRefValue>;
-interface CheckboxRefValue extends CheckboxState {
-    getRoot: () => HTMLElement | null;
-    focus: () => void;
-    blur: () => void;
-}
-interface CheckboxState {
-    setChecked: (checked: boolean) => void;
-}
-interface CheckboxProps extends Omit<AriaCheckboxProps, "isSelected" | "defaultSelected">, StyleProps {
-    /**
-     * Whether the Checkbox is checked or not; controlled
-     */
-    isChecked?: boolean;
-    /**
-     * Whether the Checkbox is checked by default; uncontrolled
-     */
-    defaultChecked?: boolean;
-    /**
-     * Whether the Checkbox is in an "indeterminate" state; this usually
-     * refers to a "check all" that is used to check / uncheck many other
-     * checkboxes, and is visually indeterminate if some of its controlled
-     * checkboxes are checked and some are not.
-     */
-    isIndeterminate?: boolean;
+interface FocusEvents$1<Target = Element> {
+  /** Handler that is called when the element receives focus. */
+  onFocus?: (e: FocusEvent<Target>) => void,
+  /** Handler that is called when the element loses focus. */
+  onBlur?: (e: FocusEvent<Target>) => void,
+  /** Handler that is called when the element's focus status changes. */
+  onFocusChange?: (isFocused: boolean) => void
 }
-interface CheckboxConfig<C extends AnyPlasmicClass> {
-    isCheckedVariant: VariantDef<PlasmicClassVariants<C>>;
-    isIndeterminateVariant?: VariantDef<PlasmicClassVariants<C>>;
-    isDisabledVariant?: VariantDef<PlasmicClassVariants<C>>;
-    noLabelVariant?: VariantDef<PlasmicClassVariants<C>>;
-    labelSlot?: keyof PlasmicClassArgs<C>;
-    root: keyof PlasmicClassOverrides<C>;
+
+interface FocusableProps$1<Target = Element> extends FocusEvents$1<Target>, KeyboardEvents$1 {
+  /** Whether the element should receive focus on render. */
+  autoFocus?: boolean
 }
-declare function useCheckbox<P extends CheckboxProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: CheckboxConfig<C>, ref?: CheckboxRef): {
-    plasmicProps: {
-        variants: PlasmicClassVariants<C>;
-        overrides: PlasmicClassOverrides<C>;
-        args: PlasmicClassArgs<C>;
-    };
-    state: CheckboxState;
-};
 
-interface BaseMenuProps extends DOMProps, AriaLabelingProps, StyleProps {
+interface BaseMenuProps extends DOMProps$1, AriaLabelingProps$1, StyleProps {
     /**
      * List of `Menu.Item`s or `Menu.Group`s that make up the menu
      */
@@ -13707,7 +13770,7 @@ interface DropdownMenuProps {
 }
 declare function DropdownMenu(props: DropdownMenuProps): React$1.JSX.Element;
 
-interface BaseMenuButtonProps extends DOMProps, FocusableProps, StyleProps, Pick<React$1.ComponentProps<"button">, "title"> {
+interface BaseMenuButtonProps extends DOMProps$1, FocusableProps$1, StyleProps, Pick<React$1.ComponentProps<"button">, "title"> {
     /**
      * The menu to show; can either be a Menu instance, or a function that returns a Menu
      * instance if you want to defer creating the instance till when it's opened.
@@ -13773,7 +13836,7 @@ declare function useMenuButton<P extends BaseMenuButtonProps, C extends AnyPlasm
     state: MenuButtonState;
 };
 
-interface BaseSelectProps extends DOMProps, AriaLabelingProps, FocusableDOMProps, InputBase, FocusableProps, StyleProps {
+interface BaseSelectProps extends DOMProps$1, AriaLabelingProps$1, FocusableDOMProps$1, InputBase$1, FocusableProps$1, StyleProps {
     /**
      * Key of the currently selected value
      */
@@ -13878,44 +13941,351 @@ declare function useSelect<P extends BaseSelectProps, C extends AnyPlasmicClass>
     state: SelectState;
 };
 
-interface BaseSelectOptionProps extends ItemLikeProps, StyleProps {
+interface BaseSelectOptionProps extends ItemLikeProps, StyleProps {
+}
+interface SelectOptionConfig<C extends AnyPlasmicClass> {
+    isSelectedVariant: VariantDef<PlasmicClassVariants<C>>;
+    isDisabledVariant?: VariantDef<PlasmicClassVariants<C>>;
+    isHighlightedVariant?: VariantDef<PlasmicClassVariants<C>>;
+    labelSlot: keyof PlasmicClassArgs<C>;
+    root: keyof PlasmicClassOverrides<C>;
+    labelContainer: keyof PlasmicClassOverrides<C>;
+}
+type SelectOptionRef = React$1.Ref<HTMLElement>;
+declare function useSelectOption<P extends BaseSelectOptionProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: SelectOptionConfig<C>, outerRef?: SelectOptionRef): {
+    plasmicProps: {
+        variants: PlasmicClassVariants<C>;
+        args: PlasmicClassArgs<C>;
+        overrides: PlasmicClassOverrides<C>;
+    };
+};
+
+interface BaseSelectOptionGroupProps extends SectionLikeProps, StyleProps {
+}
+interface SelectOptionGroupConfig<C extends AnyPlasmicClass> {
+    noTitleVariant: VariantDef<PlasmicClassVariants<C>>;
+    isFirstVariant: VariantDef<PlasmicClassVariants<C>>;
+    optionsSlot: keyof PlasmicClassArgs<C>;
+    titleSlot: keyof PlasmicClassArgs<C>;
+    root: keyof PlasmicClassOverrides<C>;
+    separator: keyof PlasmicClassOverrides<C>;
+    titleContainer: keyof PlasmicClassOverrides<C>;
+    optionsContainer: keyof PlasmicClassOverrides<C>;
+}
+declare function useSelectOptionGroup<P extends BaseSelectOptionGroupProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: SelectOptionGroupConfig<C>): {
+    plasmicProps: {
+        variants: PlasmicClassVariants<C>;
+        args: PlasmicClassArgs<C>;
+        overrides: PlasmicClassOverrides<C>;
+    };
+};
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+
+/**
+ * A generic interface to access a readonly sequential
+ * collection of unique keyed items.
+ */
+interface Collection$1<T> extends Iterable<T> {
+  /** The number of items in the collection. */
+  readonly size: number,
+
+  /** Iterate over all keys in the collection. */
+  getKeys(): Iterable<Key$1>,
+
+  /** Get an item by its key. */
+  getItem(key: Key$1): T | null,
+
+  /** Get an item by the index of its key. */
+  at(idx: number): T | null,
+
+  /** Get the key that comes before the given key in the collection. */
+  getKeyBefore(key: Key$1): Key$1 | null,
+
+  /** Get the key that comes after the given key in the collection. */
+  getKeyAfter(key: Key$1): Key$1 | null,
+
+  /** Get the first key in the collection. */
+  getFirstKey(): Key$1 | null,
+
+  /** Get the last key in the collection. */
+  getLastKey(): Key$1 | null,
+
+  /** Iterate over the child items of the given key. */
+  getChildren?(key: Key$1): Iterable<T>,
+
+  /** Returns a string representation of the item's contents. */
+  getTextValue?(key: Key$1): string,
+
+  /** Filters the collection using the given function. */
+  UNSTABLE_filter?(filterFn: (nodeValue: string) => boolean): Collection$1<T>
+}
+
+interface Node$1<T> {
+  /** The type of item this node represents. */
+  type: string,
+  /** A unique key for the node. */
+  key: Key$1,
+  /** The object value the node was created from. */
+  value: T | null,
+  /** The level of depth this node is at in the hierarchy. */
+  level: number,
+  /** Whether this item has children, even if not loaded yet. */
+  hasChildNodes: boolean,
+  /**
+   * The loaded children of this node.
+   * @deprecated Use `collection.getChildren(node.key)` instead.
+   */
+  childNodes: Iterable<Node$1<T>>,
+  /** The rendered contents of this node (e.g. JSX). */
+  rendered: ReactNode,
+  /** A string value for this node, used for features like typeahead. */
+  textValue: string,
+  /** An accessibility label for this node. */
+  'aria-label'?: string,
+  /** The index of this node within its parent. */
+  index: number,
+  /** A function that should be called to wrap the rendered node. */
+  wrapper?: (element: ReactElement) => ReactElement,
+  /** The key of the parent node. */
+  parentKey?: Key$1 | null,
+  /** The key of the node before this node. */
+  prevKey?: Key$1 | null,
+  /** The key of the node after this node. */
+  nextKey?: Key$1 | null,
+  /** Additional properties specific to a particular node type. */
+  props?: any,
+  /** @private */
+  shouldInvalidate?: (context: any) => boolean,
+  /** A function that renders this node to a React Element in the DOM. */
+  render?: (node: Node$1<any>) => ReactElement
+}
+
+/*
+ * Copyright 2023 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+type Key$1 = string | number;
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+
+type SelectionMode = 'none' | 'single' | 'multiple';
+type SelectionBehavior = 'toggle' | 'replace';
+type Selection = 'all' | Set<Key>;
+
+type FocusStrategy = 'first' | 'last';
+type DisabledBehavior = 'selection' | 'all';
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+
+interface Rect {
+  x: number,
+  y: number,
+  width: number,
+  height: number
+}
+
+interface Size {
+  width: number,
+  height: number
+}
+
+/** A LayoutDelegate provides layout information for collection items. */
+interface LayoutDelegate {
+  /** Returns a rectangle for the item with the given key. */
+  getItemRect(key: Key): Rect | null,
+  /** Returns the visible rectangle of the collection. */
+  getVisibleRect(): Rect,
+  /** Returns the size of the scrollable content in the collection. */
+  getContentSize(): Size,
+  /** Returns a list of keys between `from` and `to`. */
+  getKeyRange?(from: Key, to: Key): Key[]
+}
+
+/**
+ * A generic interface to access a readonly sequential
+ * collection of unique keyed items.
+ */
+interface Collection<T> extends Iterable<T> {
+  /** The number of items in the collection. */
+  readonly size: number,
+
+  /** Iterate over all keys in the collection. */
+  getKeys(): Iterable<Key>,
+
+  /** Get an item by its key. */
+  getItem(key: Key): T | null,
+
+  /** Get an item by the index of its key. */
+  at(idx: number): T | null,
+
+  /** Get the key that comes before the given key in the collection. */
+  getKeyBefore(key: Key): Key | null,
+
+  /** Get the key that comes after the given key in the collection. */
+  getKeyAfter(key: Key): Key | null,
+
+  /** Get the first key in the collection. */
+  getFirstKey(): Key | null,
+
+  /** Get the last key in the collection. */
+  getLastKey(): Key | null,
+
+  /** Iterate over the child items of the given key. */
+  getChildren?(key: Key): Iterable<T>,
+
+  /** Returns a string representation of the item's contents. */
+  getTextValue?(key: Key): string,
+
+  /** Filters the collection using the given function. */
+  UNSTABLE_filter?(filterFn: (nodeValue: string) => boolean): Collection<T>
 }
-interface SelectOptionConfig<C extends AnyPlasmicClass> {
-    isSelectedVariant: VariantDef<PlasmicClassVariants<C>>;
-    isDisabledVariant?: VariantDef<PlasmicClassVariants<C>>;
-    isHighlightedVariant?: VariantDef<PlasmicClassVariants<C>>;
-    labelSlot: keyof PlasmicClassArgs<C>;
-    root: keyof PlasmicClassOverrides<C>;
-    labelContainer: keyof PlasmicClassOverrides<C>;
+
+interface Node<T> {
+  /** The type of item this node represents. */
+  type: string,
+  /** A unique key for the node. */
+  key: Key,
+  /** The object value the node was created from. */
+  value: T | null,
+  /** The level of depth this node is at in the hierarchy. */
+  level: number,
+  /** Whether this item has children, even if not loaded yet. */
+  hasChildNodes: boolean,
+  /**
+   * The loaded children of this node.
+   * @deprecated Use `collection.getChildren(node.key)` instead.
+   */
+  childNodes: Iterable<Node<T>>,
+  /** The rendered contents of this node (e.g. JSX). */
+  rendered: ReactNode,
+  /** A string value for this node, used for features like typeahead. */
+  textValue: string,
+  /** An accessibility label for this node. */
+  'aria-label'?: string,
+  /** The index of this node within its parent. */
+  index: number,
+  /** A function that should be called to wrap the rendered node. */
+  wrapper?: (element: ReactElement) => ReactElement,
+  /** The key of the parent node. */
+  parentKey?: Key | null,
+  /** The key of the node before this node. */
+  prevKey?: Key | null,
+  /** The key of the node after this node. */
+  nextKey?: Key | null,
+  /** Additional properties specific to a particular node type. */
+  props?: any,
+  /** @private */
+  shouldInvalidate?: (context: any) => boolean,
+  /** A function that renders this node to a React Element in the DOM. */
+  render?: (node: Node<any>) => ReactElement
 }
-type SelectOptionRef = React$1.Ref<HTMLElement>;
-declare function useSelectOption<P extends BaseSelectOptionProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: SelectOptionConfig<C>, outerRef?: SelectOptionRef): {
-    plasmicProps: {
-        variants: PlasmicClassVariants<C>;
-        args: PlasmicClassArgs<C>;
-        overrides: PlasmicClassOverrides<C>;
-    };
-};
 
-interface BaseSelectOptionGroupProps extends SectionLikeProps, StyleProps {
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+
+type PointerType = 'mouse' | 'pen' | 'touch' | 'keyboard' | 'virtual';
+
+interface PressEvent {
+  /** The type of press event being fired. */
+  type: 'pressstart' | 'pressend' | 'pressup' | 'press',
+  /** The pointer type that triggered the press event. */
+  pointerType: PointerType,
+  /** The target element of the press event. */
+  target: Element,
+  /** Whether the shift keyboard modifier was held during the press event. */
+  shiftKey: boolean,
+  /** Whether the ctrl keyboard modifier was held during the press event. */
+  ctrlKey: boolean,
+  /** Whether the meta keyboard modifier was held during the press event. */
+  metaKey: boolean,
+  /** Whether the alt keyboard modifier was held during the press event. */
+  altKey: boolean,
+  /** X position relative to the target. */
+  x: number,
+  /** Y position relative to the target. */
+  y: number,
+  /**
+   * By default, press events stop propagation to parent elements.
+   * In cases where a handler decides not to handle a specific event,
+   * it can call `continuePropagation()` to allow a parent to handle it.
+   */
+  continuePropagation(): void
 }
-interface SelectOptionGroupConfig<C extends AnyPlasmicClass> {
-    noTitleVariant: VariantDef<PlasmicClassVariants<C>>;
-    isFirstVariant: VariantDef<PlasmicClassVariants<C>>;
-    optionsSlot: keyof PlasmicClassArgs<C>;
-    titleSlot: keyof PlasmicClassArgs<C>;
-    root: keyof PlasmicClassOverrides<C>;
-    separator: keyof PlasmicClassOverrides<C>;
-    titleContainer: keyof PlasmicClassOverrides<C>;
-    optionsContainer: keyof PlasmicClassOverrides<C>;
+
+interface LongPressEvent extends Omit<PressEvent, 'type' | 'continuePropagation'> {
+  /** The type of long press event being fired. */
+  type: 'longpressstart' | 'longpressend' | 'longpress'
 }
-declare function useSelectOptionGroup<P extends BaseSelectOptionGroupProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: SelectOptionGroupConfig<C>): {
-    plasmicProps: {
-        variants: PlasmicClassVariants<C>;
-        args: PlasmicClassArgs<C>;
-        overrides: PlasmicClassOverrides<C>;
-    };
-};
+
+/*
+ * Copyright 2023 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+type Key = string | number;
 
 interface FocusState {
     /** Whether the collection is currently focused. */
@@ -13923,11 +14293,11 @@ interface FocusState {
     /** Sets whether the collection is focused. */
     setFocused(isFocused: boolean): void;
     /** The current focused key in the collection. */
-    readonly focusedKey: Key;
+    readonly focusedKey: Key | null;
     /** Whether the first or last child of the focused key should receive focus. */
-    readonly childFocusStrategy: FocusStrategy;
+    readonly childFocusStrategy: FocusStrategy | null;
     /** Sets the focused key, and optionally, whether the first or last child of that key should receive focus. */
-    setFocusedKey(key: Key, child?: FocusStrategy): void;
+    setFocusedKey(key: Key | null, child?: FocusStrategy): void;
 }
 interface MultipleSelectionState extends FocusState {
     /** The type of selection that is allowed in the collection. */
@@ -14001,14 +14371,18 @@ interface MultipleSelectionManager extends FocusState {
     isLink(key: Key): boolean;
     /** Returns the props for the given item. */
     getItemProps(key: Key): any;
+    /** The collection of nodes that the selection manager handles. */
+    collection: Collection<Node<unknown>>;
 }
 interface SelectionManagerOptions {
     allowsCellSelection?: boolean;
+    layoutDelegate?: LayoutDelegate;
 }
 /**
  * An interface for reading and updating multiple selection state.
  */
 declare class SelectionManager implements MultipleSelectionManager {
+    collection: Collection<Node<unknown>>;
     constructor(collection: Collection<Node<unknown>>, state: MultipleSelectionState, options?: SelectionManagerOptions);
     /**
      * The type of selection that is allowed in the collection.
@@ -14037,9 +14411,9 @@ declare class SelectionManager implements MultipleSelectionManager {
     /**
      * The current focused key in the collection.
      */
-    get focusedKey(): Key;
+    get focusedKey(): Key | null;
     /** Whether the first or last child of the focused key should receive focus. */
-    get childFocusStrategy(): FocusStrategy;
+    get childFocusStrategy(): FocusStrategy | null;
     /**
      * Sets the focused key.
      */
@@ -14106,13 +14480,14 @@ declare class SelectionManager implements MultipleSelectionManager {
     isDisabled(key: Key): boolean;
     isLink(key: Key): boolean;
     getItemProps(key: Key): any;
+    withCollection(collection: Collection<Node<unknown>>): SelectionManager;
 }
 
 interface ListState<T> {
     /** A collection of items in the list. */
-    collection: Collection<Node<T>>;
+    collection: Collection$1<Node$1<T>>;
     /** A set of items that are disabled. */
-    disabledKeys: Set<Key>;
+    disabledKeys: Set<Key$1>;
     /** A selection manager to read and update multiple selection state. */
     selectionManager: SelectionManager;
 }
@@ -14133,6 +14508,136 @@ declare const SelectContext: React$1.Context<ListState<any> | undefined>;
 
 
 
+interface AriaLabelingProps {
+  /**
+   * Defines a string value that labels the current element.
+   */
+  'aria-label'?: string,
+
+  /**
+   * Identifies the element (or elements) that labels the current element.
+   */
+  'aria-labelledby'?: string,
+
+  /**
+   * Identifies the element (or elements) that describes the object.
+   */
+  'aria-describedby'?: string,
+
+  /**
+   * Identifies the element (or elements) that provide a detailed, extended description for the object.
+   */
+  'aria-details'?: string
+}
+
+// A set of common DOM props that are allowed on any component
+// Ensure this is synced with DOMPropNames in filterDOMProps
+interface DOMProps {
+  /**
+   * The element's unique identifier. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/id).
+   */
+  id?: string
+}
+
+interface FocusableDOMProps extends DOMProps {
+  /**
+   * Whether to exclude the element from the sequential tab order. If true,
+   * the element will not be focusable via the keyboard by tabbing. This should
+   * be avoided except in rare scenarios where an alternative means of accessing
+   * the element or its functionality via the keyboard is available.
+   */
+  excludeFromTabOrder?: boolean
+}
+
+interface InputDOMProps {
+  /**
+   * The name of the input element, used when submitting an HTML form. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefname).
+   */
+  name?: string
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+
+interface InputBase {
+  /** Whether the input is disabled. */
+  isDisabled?: boolean,
+  /** Whether the input can be selected but not changed by the user. */
+  isReadOnly?: boolean
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+
+// Event bubbling can be problematic in real-world applications, so the default for React Spectrum components
+// is not to propagate. This can be overridden by calling continuePropagation() on the event.
+type BaseEvent<T extends SyntheticEvent> = T & {
+  /**
+   * Use continuePropagation.
+   * @deprecated */
+  stopPropagation(): void,
+  continuePropagation(): void
+}
+
+type KeyboardEvent = BaseEvent<KeyboardEvent$3<any>>;
+
+interface KeyboardEvents {
+  /** Handler that is called when a key is pressed. */
+  onKeyDown?: (e: KeyboardEvent) => void,
+  /** Handler that is called when a key is released. */
+  onKeyUp?: (e: KeyboardEvent) => void
+}
+
+interface FocusEvents<Target = Element> {
+  /** Handler that is called when the element receives focus. */
+  onFocus?: (e: FocusEvent<Target>) => void,
+  /** Handler that is called when the element loses focus. */
+  onBlur?: (e: FocusEvent<Target>) => void,
+  /** Handler that is called when the element's focus status changes. */
+  onFocusChange?: (isFocused: boolean) => void
+}
+
+interface FocusableProps<Target = Element> extends FocusEvents<Target>, KeyboardEvents {
+  /** Whether the element should receive focus on render. */
+  autoFocus?: boolean
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+
 interface SwitchBase extends InputBase, FocusableProps {
   /**
    * The content to render as the Switch's label.
@@ -14237,7 +14742,7 @@ declare function useTextInput<P extends PlumeTextInputProps, C extends AnyPlasmi
     };
 };
 
-interface BaseTriggeredOverlayProps extends StyleProps, DOMProps {
+interface BaseTriggeredOverlayProps extends StyleProps, DOMProps$1 {
     children?: React$1.ReactNode;
 }
 interface TriggeredOverlayConfig<C extends AnyPlasmicClass> {
@@ -14273,7 +14778,7 @@ interface OverlayTriggerState {
 interface TriggeredOverlayContextValue {
     triggerRef: React$1.RefObject<HTMLElement>;
     state: OverlayTriggerState;
-    autoFocus?: boolean | FocusStrategy;
+    autoFocus?: boolean | FocusStrategy$1;
     placement?: Placement;
     overlayMatchTriggerWidth?: boolean;
     overlayMinTriggerWidth?: boolean;