@plasmicapp/react-web 0.2.429 → 1.0.0

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$2, 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 {
@@ -12168,7 +12168,6 @@ interface RichCustomType<P> extends PropTypeBaseDefault<P, any> {
 type CustomType<P> = RichCustomType<P> | CustomControl<P>;
 interface DynamicType$1<P> extends PropTypeBase<ComponentControlContext<P>>, DynamicCore<ComponentControlContext<P>, PropType$1<P>> {
 }
-type PrimitiveType<P = any> = Extract<StringType$1<P> | BooleanType$1<P> | NumberType$1<P> | JSONLikeType<P>, string>;
 type PropType$1<P> = StringType$1<P> | BooleanType$1<P> | GraphQLType$1<P> | NumberType$1<P> | JSONLikeType<P> | DataSourceType<P> | DataPickerType<P> | ExprEditorType<P> | FormValidationRulesType<P> | EventHandlerType<P> | ChoiceType$1<P> | CustomType<P> | DynamicType$1<P> | ImageUrlType<P> | SlotType<P> | DateStringType$1<P> | DateRangeStringsType$1<P>;
 type ArgType<P> = Exclude<PropType$1<P>, SlotType<P> | EventHandlerType<P>>;
 type StringCompatType<P> = DateStringType$1<P> | StringType$1<P> | ChoiceType$1<P> | JSONLikeType<P> | ImageUrlType<P> | CustomType<P> | DataPickerType<P>;
@@ -12176,45 +12175,6 @@ type BoolCompatType<P> = BooleanType$1<P> | CustomType<P> | DataPickerType<P>;
 type NumberCompatType<P> = NumberType$1<P> | CustomType<P> | DataPickerType<P>;
 type RestrictPropType$1<T, P> = T extends string ? StringCompatType<P> : T extends boolean ? BoolCompatType<P> : T extends number ? NumberCompatType<P> : PropType$1<P>;
 
-type Fetcher = (...args: any[]) => Promise<any>;
-interface FetcherMeta {
-    /**
-     * Any unique identifying string for this fetcher.
-     */
-    name: string;
-    /**
-     * The Studio-user-friendly display name.
-     */
-    displayName?: string;
-    /**
-     * The symbol to import from the importPath.
-     */
-    importName?: string;
-    args: {
-        name: string;
-        type: PrimitiveType;
-    }[];
-    returns: PrimitiveType;
-    /**
-     * Either the path to the fetcher relative to `rootDir` or the npm
-     * package name
-     */
-    importPath: string;
-    /**
-     * Whether it's a default export or named export
-     */
-    isDefaultExport?: boolean;
-}
-interface FetcherRegistration {
-    fetcher: Fetcher;
-    meta: FetcherMeta;
-}
-declare global {
-    interface Window {
-        __PlasmicFetcherRegistry: FetcherRegistration[];
-    }
-}
-
 /**
  * Control type for building a custom query format.
  *
@@ -13040,10 +13000,6 @@ interface PlasmicRootProviderProps extends PlasmicDataSourceContextValue {
     platform?: "nextjs" | "gatsby";
     children?: React$1.ReactNode;
     i18n?: PlasmicI18NContextValue;
-    /**
-     * @deprecated use i18n.translator instead
-     */
-    translator?: PlasmicTranslator;
     Head?: React$1.ComponentType<any>;
     Link?: React$1.ComponentType<any>;
     disableLoadingBoundary?: boolean;
@@ -13198,7 +13154,189 @@ declare function Trans({ transKey, children }: TransProps): React__default.React
 
 
 
-interface AriaLabelingProps$1 {
+/** 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.
    */
@@ -13230,14 +13368,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$1 {
+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$1 extends DOMProps$1 {
+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
@@ -13247,25 +13385,13 @@ interface FocusableDOMProps$1 extends DOMProps$1 {
   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");
@@ -13307,7 +13433,7 @@ interface Validation<T = unknown> {
   validate?: (value: T) => ValidationError | true | null | undefined
 }
 
-interface InputBase$1 {
+interface InputBase$2 {
   /** Whether the input is disabled. */
   isDisabled?: boolean,
   /** Whether the input can be selected but not changed by the user. */
@@ -13328,12 +13454,38 @@ interface InputBase$1 {
 
 
 
-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$1 = '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.
@@ -13349,349 +13501,7 @@ type DisabledBehavior = 'selection' | 'all';
 
 
 
-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 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
-}
-
-/*
- * 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$1<T extends SyntheticEvent> = T & {
-  /**
-   * Use continuePropagation.
-   * @deprecated */
-  stopPropagation(): void,
-  continuePropagation(): void
-}
-
-type KeyboardEvent$1 = BaseEvent$1<KeyboardEvent$2<any>>;
-
-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 LongPressEvent extends Omit<PressEvent, 'type' | 'continuePropagation'> {
-  /** The type of long press event being fired. */
-  type: 'longpressstart' | 'longpressend' | 'longpress'
-}
-
-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
-}
-
-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 FocusableProps$1<Target = Element> extends FocusEvents$1<Target>, KeyboardEvents$1 {
-  /** Whether the element should receive focus on render. */
-  autoFocus?: boolean
-}
-
-/*
- * 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 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;
-}
-
-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 ToggleStateOptions extends InputBase$1 {
+interface ToggleStateOptions extends InputBase$2 {
   /**
    * Whether the element should be selected (uncontrolled).
    */
@@ -13706,7 +13516,7 @@ interface ToggleStateOptions extends InputBase$1 {
   onChange?: (isSelected: boolean) => void
 }
 
-interface ToggleProps extends ToggleStateOptions, Validation<boolean>, FocusableProps$1 {
+interface ToggleProps extends ToggleStateOptions, Validation<boolean>, FocusableProps$2 {
   /**
    * The label for the element.
    */
@@ -13717,7 +13527,7 @@ interface ToggleProps extends ToggleStateOptions, Validation<boolean>, Focusable
   value?: string
 }
 
-interface AriaToggleProps extends ToggleProps, FocusableDOMProps$1, AriaLabelingProps$1, AriaValidationProps, InputDOMProps {
+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.
    */
@@ -13797,7 +13607,7 @@ declare function useCheckbox<P extends CheckboxProps, C extends AnyPlasmicClass>
 
 
 
-interface AriaLabelingProps {
+interface AriaLabelingProps$1 {
   /**
    * Defines a string value that labels the current element.
    */
@@ -13821,14 +13631,14 @@ interface AriaLabelingProps {
 
 // A set of common DOM props that are allowed on any component
 // Ensure this is synced with DOMPropNames in filterDOMProps
-interface DOMProps {
+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 FocusableDOMProps extends DOMProps {
+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
@@ -13852,7 +13662,7 @@ interface FocusableDOMProps extends DOMProps {
 
 
 
-interface InputBase {
+interface InputBase$1 {
   /** Whether the input is disabled. */
   isDisabled?: boolean,
   /** Whether the input can be selected but not changed by the user. */
@@ -13873,7 +13683,7 @@ interface InputBase {
 
 
 
-type FocusStrategy = 'first' | 'last';
+type FocusStrategy$1 = 'first' | 'last';
 
 /*
  * Copyright 2020 Adobe. All rights reserved.
@@ -13891,7 +13701,7 @@ type FocusStrategy = 'first' | 'last';
 
 // 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 & {
+type BaseEvent$1<T extends SyntheticEvent> = T & {
   /**
    * Use continuePropagation.
    * @deprecated */
@@ -13899,16 +13709,16 @@ type BaseEvent<T extends SyntheticEvent> = T & {
   continuePropagation(): void
 }
 
-type KeyboardEvent = BaseEvent<KeyboardEvent$2<any>>;
+type KeyboardEvent$1 = BaseEvent$1<KeyboardEvent$3<any>>;
 
-interface KeyboardEvents {
+interface KeyboardEvents$1 {
   /** Handler that is called when a key is pressed. */
-  onKeyDown?: (e: KeyboardEvent) => void,
+  onKeyDown?: (e: KeyboardEvent$1) => void,
   /** Handler that is called when a key is released. */
-  onKeyUp?: (e: KeyboardEvent) => void
+  onKeyUp?: (e: KeyboardEvent$1) => void
 }
 
-interface FocusEvents<Target = Element> {
+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. */
@@ -13917,12 +13727,12 @@ interface FocusEvents<Target = Element> {
   onFocusChange?: (isFocused: boolean) => void
 }
 
-interface FocusableProps<Target = Element> extends FocusEvents<Target>, KeyboardEvents {
+interface FocusableProps$1<Target = Element> extends FocusEvents$1<Target>, KeyboardEvents$1 {
   /** Whether the element should receive focus on render. */
   autoFocus?: boolean
 }
 
-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
      */
@@ -14164,7 +13974,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.
@@ -14230,7 +14040,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
      */
@@ -14326,53 +14136,360 @@ interface SelectState {
     getSelectedValue: () => string | null;
     setSelectedValue: (value: string | null) => void;
 }
-declare function useSelect<P extends BaseSelectProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: SelectConfig<C>, ref?: React$1.Ref<SelectRefValue>): {
-    plasmicProps: {
-        variants: PlasmicClassVariants<C>;
-        args: PlasmicClassArgs<C>;
-        overrides: PlasmicClassOverrides<C>;
-    };
-    state: SelectState;
-};
+declare function useSelect<P extends BaseSelectProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: SelectConfig<C>, ref?: React$1.Ref<SelectRefValue>): {
+    plasmicProps: {
+        variants: PlasmicClassVariants<C>;
+        args: PlasmicClassArgs<C>;
+        overrides: PlasmicClassOverrides<C>;
+    };
+    state: SelectState;
+};
+
+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 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
+}
 
-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>;
-    };
-};
+/*
+ * 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 BaseSelectOptionGroupProps extends SectionLikeProps, StyleProps {
+
+
+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. */
@@ -14382,9 +14499,9 @@ interface FocusState {
     /** The current focused key in the collection. */
     readonly focusedKey: Key | null;
     /** Whether the first or last child of the focused key should receive focus. */
-    readonly childFocusStrategy: FocusStrategy$1 | null;
+    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 | null, child?: FocusStrategy$1): void;
+    setFocusedKey(key: Key | null, child?: FocusStrategy): void;
 }
 interface MultipleSelectionState extends FocusState {
     /** The type of selection that is allowed in the collection. */
@@ -14500,11 +14617,11 @@ declare class SelectionManager implements MultipleSelectionManager {
      */
     get focusedKey(): Key | null;
     /** Whether the first or last child of the focused key should receive focus. */
-    get childFocusStrategy(): FocusStrategy$1 | null;
+    get childFocusStrategy(): FocusStrategy | null;
     /**
      * Sets the focused key.
      */
-    setFocusedKey(key: Key | null, childFocusStrategy?: FocusStrategy$1): void;
+    setFocusedKey(key: Key | null, childFocusStrategy?: FocusStrategy): void;
     /**
      * The currently selected keys in the collection.
      */
@@ -14572,9 +14689,9 @@ declare class SelectionManager implements MultipleSelectionManager {
 
 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;
 }
@@ -14595,7 +14712,137 @@ declare const SelectContext: React$1.Context<ListState<any> | undefined>;
 
 
 
-interface SwitchBase extends InputBase$1, FocusableProps$1 {
+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.
    */
@@ -14618,7 +14865,7 @@ interface SwitchBase extends InputBase$1, FocusableProps$1 {
   value?: string
 }
 interface SwitchProps$1 extends SwitchBase {}
-interface AriaSwitchBase extends SwitchBase, FocusableDOMProps$1, InputDOMProps, AriaLabelingProps$1 {
+interface AriaSwitchBase extends SwitchBase, FocusableDOMProps, InputDOMProps, AriaLabelingProps {
   /**
    * Identifies the element (or elements) whose contents or presence are controlled by the current element.
    */
@@ -14699,7 +14946,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> {
@@ -14735,7 +14982,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;