@plasmicapp/react-web 0.2.388 → 0.2.390

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$2, AriaRole, CSSProperties as CSSProperties$1, FocusEvent, KeyboardEvent as KeyboardEvent$3, SyntheticEvent, ReactNode, ReactElement } 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';
 
 declare global {
     interface Window {
@@ -11373,6 +11373,8 @@ interface CodeComponentElement<P> {
 }
 type PlasmicElement = ImageElement | TextElement | ContainerElement | ButtonElement | TextInputElement | CodeComponentElement<{}> | DefaultComponentElement<{}>;
 
+type Nullish<T> = T | null | undefined;
+
 interface ActionProps<P> {
     componentProps: P;
     /**
@@ -12223,18 +12225,18 @@ interface CustomChoiceType<P, T> extends ChoiceTypeBase<P, T | T[]> {
     multiSelect: ContextDependentConfig<P, boolean>;
 }
 type ChoiceType<P, T> = SingleChoiceType<P, T> | MultiChoiceType<P, T> | CustomChoiceType<P, T>;
-interface PlainStringType<T extends string = string> extends BaseParam {
+interface PlainStringType<T extends Nullish<string> = string> extends BaseParam {
     type: "string" | `'${T}'`;
 }
-type StringType<P, T extends string = string> = "string" | PlainStringType<T> | ChoiceType<P, T> | AnyType;
-interface PlainNumberType<T extends number = number> extends BaseParam {
+type StringType<P, T extends Nullish<string> = string> = "string" | PlainStringType<T> | ChoiceType<P, T> | AnyType;
+interface PlainNumberType<T extends Nullish<number> = number> extends BaseParam {
     type: "number" | `${number extends T ? number : T}`;
 }
-type NumberType<P, T extends number = number> = PlainNumberType<T> | ChoiceType<P, T> | AnyType;
-interface PlainBooleanType<T extends boolean = boolean> extends BaseParam {
+type NumberType<P, T extends Nullish<number> = number> = PlainNumberType<T> | ChoiceType<P, T> | AnyType;
+interface PlainBooleanType<T extends Nullish<boolean> = boolean> extends BaseParam {
     type: "boolean" | `${boolean extends T ? boolean : T}`;
 }
-type BooleanType<P, T extends boolean = boolean> = PlainBooleanType<T> | ChoiceType<P, T> | AnyType;
+type BooleanType<P, T extends Nullish<boolean> = boolean> = PlainBooleanType<T> | ChoiceType<P, T> | AnyType;
 type GraphQLValue = {
     query: string;
     variables?: Record<string, any>;
@@ -12273,7 +12275,7 @@ type VoidType = PlainVoidType | AnyType;
 type IsAny<T> = 0 extends 1 & T ? true : false;
 type CommonType<P, T> = T extends GraphQLValue ? GraphQLType<P> : T extends null ? NullType : T extends undefined ? UndefinedType : T extends Array<any> ? ArrayType : T extends object ? ObjectType : AnyType;
 type AnyTyping<P, T> = T extends string ? StringType<P, T> : T extends number ? NumberType<P, T> : T extends boolean ? BooleanType<P, T> : CommonType<P, T>;
-type RestrictedType<P, T> = IsAny<T> extends true ? AnyTyping<P, T> : [T] extends [string] ? StringType<P, T> : [T] extends [number] ? NumberType<P, T> : [T] extends [boolean] ? BooleanType<P, T> : CommonType<P, T>;
+type RestrictedType<P, T> = IsAny<T> extends true ? AnyTyping<P, T> : [T] extends [Nullish<string>] ? StringType<P, T> : [T] extends [Nullish<number>] ? NumberType<P, T> : [T] extends [Nullish<boolean>] ? BooleanType<P, T> : CommonType<P, T>;
 type ParamType<P, T> = RestrictedType<P, T>;
 type RequiredParam<P, T> = ParamType<P, T> & {
     isOptional?: false;
@@ -12950,189 +12952,7 @@ declare function Trans({ transKey, children }: TransProps): React__default.React
 
 
 
-/** 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 {
+interface AriaLabelingProps$1 {
   /**
    * Defines a string value that labels the current element.
    */
@@ -13164,14 +12984,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$2 {
+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$2 extends DOMProps$2 {
+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
@@ -13181,13 +13001,25 @@ interface FocusableDOMProps$2 extends DOMProps$2 {
   excludeFromTabOrder?: boolean
 }
 
-interface InputDOMProps$1 {
+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
 }
 
+/** 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");
@@ -13229,7 +13061,7 @@ interface Validation<T = unknown> {
   validate?: (value: T) => ValidationError | true | null | undefined
 }
 
-interface InputBase$2 {
+interface InputBase$1 {
   /** Whether the input is disabled. */
   isDisabled?: boolean,
   /** Whether the input can be selected but not changed by the user. */
@@ -13250,38 +13082,12 @@ interface InputBase$2 {
 
 
 
-// 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 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
-}
+type SelectionMode = 'none' | 'single' | 'multiple';
+type SelectionBehavior = 'toggle' | 'replace';
+type Selection = 'all' | Set<Key>;
 
-interface FocusableProps$2<Target = Element> extends FocusEvents$2<Target>, KeyboardEvents$2 {
-  /** Whether the element should receive focus on render. */
-  autoFocus?: boolean
-}
+type FocusStrategy$1 = 'first' | 'last';
+type DisabledBehavior = 'selection' | 'all';
 
 /*
  * Copyright 2020 Adobe. All rights reserved.
@@ -13297,172 +13103,107 @@ interface FocusableProps$2<Target = Element> extends FocusEvents$2<Target>, Keyb
 
 
 
-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
+interface Rect {
+  x: number,
+  y: number,
+  width: number,
+  height: number
 }
 
-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
+interface Size {
+  width: number,
+  height: number
 }
 
-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
-}
-
-interface CheckboxProps$1 extends ToggleProps {
-  /**
-   * Indeterminism is presentational only.
-   * The indeterminate visual representation remains regardless of user interaction.
-   */
-  isIndeterminate?: boolean
+/** 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[]
 }
 
-interface AriaCheckboxProps extends CheckboxProps$1, AriaToggleProps {}
+/**
+ * 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 StyleProps {
-    className?: string;
-    style?: React$1.CSSProperties;
-}
-declare function getDataProps(props: Record<string, any>): Partial<Record<string, any>>;
+  /** Iterate over all keys in the collection. */
+  getKeys(): Iterable<Key>,
 
-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;
-};
+  /** Get an item by its key. */
+  getItem(key: Key): T | null,
 
-/*
- * 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.
- */
+  /** 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,
 
-interface AriaLabelingProps$1 {
-  /**
-   * Defines a string value that labels the current element.
-   */
-  'aria-label'?: string,
+  /** Get the first key in the collection. */
+  getFirstKey(): Key | null,
 
-  /**
-   * Identifies the element (or elements) that labels the current element.
-   */
-  'aria-labelledby'?: string,
+  /** Get the last key in the collection. */
+  getLastKey(): Key | null,
 
-  /**
-   * Identifies the element (or elements) that describes the object.
-   */
-  'aria-describedby'?: string,
+  /** Iterate over the child items of the given key. */
+  getChildren?(key: Key): Iterable<T>,
 
-  /**
-   * Identifies the element (or elements) that provide a detailed, extended description for the object.
-   */
-  'aria-details'?: string
-}
+  /** Returns a string representation of the item's contents. */
+  getTextValue?(key: Key): string,
 
-// 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
+  /** Filters the collection using the given function. */
+  UNSTABLE_filter?(filterFn: (nodeValue: string) => boolean): Collection<T>
 }
 
-interface FocusableDOMProps$1 extends DOMProps$1 {
+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,
   /**
-   * 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.
+   * The loaded children of this node.
+   * @deprecated Use `collection.getChildren(node.key)` instead.
    */
-  excludeFromTabOrder?: 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 InputBase$1 {
-  /** Whether the input is disabled. */
-  isDisabled?: boolean,
-  /** Whether the input can be selected but not changed by the user. */
-  isReadOnly?: boolean
+  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
 }
 
 /*
@@ -13479,22 +13220,6 @@ interface InputBase$1 {
 
 
 
-type FocusStrategy$1 = 'first' | 'last';
-
-/*
- * 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 & {
@@ -13505,7 +13230,41 @@ type BaseEvent$1<T extends SyntheticEvent> = T & {
   continuePropagation(): void
 }
 
-type KeyboardEvent$1 = BaseEvent$1<KeyboardEvent$3<any>>;
+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. */
@@ -13528,199 +13287,8 @@ interface FocusableProps$1<Target = Element> extends FocusEvents$1<Target>, Keyb
   autoFocus?: boolean
 }
 
-interface BaseMenuProps extends DOMProps$1, AriaLabelingProps$1, StyleProps {
-    /**
-     * List of `Menu.Item`s or `Menu.Group`s that make up the menu
-     */
-    children?: React$1.ReactNode;
-    /**
-     * Called with the value of a `Menu.Item` when it is selected.
-     */
-    onAction?: (value: string) => void;
-}
-type MenuRef = React$1.Ref<MenuRefValue>;
-interface MenuRefValue extends MenuState {
-    getRoot: () => HTMLElement | null;
-}
-interface MenuConfig<C extends AnyPlasmicClass> {
-    isPlacedTopVariant?: VariantDef<PlasmicClassVariants<C>>;
-    isPlacedBottomVariant?: VariantDef<PlasmicClassVariants<C>>;
-    isPlacedLeftVariant?: VariantDef<PlasmicClassVariants<C>>;
-    isPlacedRightVariant?: VariantDef<PlasmicClassVariants<C>>;
-    itemsSlot: keyof PlasmicClassArgs<C>;
-    itemsContainer: keyof PlasmicClassOverrides<C>;
-    root: keyof PlasmicClassOverrides<C>;
-}
-interface MenuState {
-    getFocusedValue: () => string | null;
-    setFocusedValue: (value: string) => void;
-}
-declare function useMenu<P extends BaseMenuProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: MenuConfig<C>, ref?: MenuRef): {
-    plasmicProps: {
-        variants: PlasmicClassVariants<C>;
-        args: PlasmicClassArgs<C>;
-        overrides: PlasmicClassOverrides<C>;
-    };
-    state: MenuState;
-};
-
-/**
- * In general, we try not to expose react-aria's Collections API to Plume users.
- * The Collections API is how react-aria users pass data about collections of
- * things using the built-in Item and Section components, which are abstract,
- * metadata-only components that don't render anything but only serve to specify
- * data.  For example, here's how you would use react-spectrum's Picker:
- *
- *   <Picker>
- *     <Section title="Asia">
- *       <Item key="taiwan">Taiwan</Item>
- *       <Item key="japan">Japan</Item>
- *       <Item key="china">China</Item>
- *     </Section>
- *     <Section title="Europe">
- *       <Item key="germany">Germany</Item>
- *       <Item key="france">France</Item>
- *     </Section>
- *   </Picker>
- *
- * You would re-use this same Item/Section components to pass similar things to
- * Menu, Tabs, etc.
- *
- * For Plasmic, this API is too abstract.  The user has explicitly designed components
- * like Select.Option and Select.OptionGroup, and it is weird that they don't actually
- * use these components. It is more natural to do:
- *
- *   <Select>
- *     <Select.OptionGroup title="Asia">
- *       <Select.Option key="taiwan">Taiwan</Select>
- *     </Select.OptionGroup>
- *   </Select>
- *
- * For Plume, we let users directly use the components they designed, both to collect
- * information and to perform actual rendering.  For example, for Plume,
- * you'd use Select.Option instead of Item, and Select.OptionGroup instead of Section.
- * This means that the Select.Option props will collect the same information Item
- * does.
- *
- * A component like Select.Option then serves two purposes:
- *
- * 1. Allow users to specify the collection of data, like in the above example
- *    Here, we're mainly interested in the props in those ReactElements so
- *    we can pass the Item/Section data onto react-aria's APIs.  We are not
- *    actually rendering these elements.
- * 2. Once react-aria's Collections API has gone through them and built
- *    Collection "nodes", we then create cloned versions of these elements
- *    with the corresponding node passed in as a secret prop.  These ReactElements
- *    are then actually used to _render_ the corresponding Option / OptionGroup.
- *
- * This file contains helper functions to help with implementing the above.
- *
- * Note also that most of the collections-based react-aria components expose
- * a parallel API that accepts a list of "items" and a render prop, instead
- * of list of Item/Section elements.  This is for efficiency, but we are opting
- * to only support the composite-component pattern for now for simplicity.
- */
-
-/**
- * Props for a Plume component that corresponds to an Item
- */
-interface ItemLikeProps {
-    /**
-     * value key corresponding to this item. Not required if you use the
-     * `key` prop instead.
-     */
-    value?: string | null;
-    /**
-     * The text string value corresponding to this item. Used to support
-     * keyboard type-ahead.  If not specified, then will be derived from
-     * `children` if it is a string, or the `value` or `key`.
-     */
-    textValue?: string;
-    /**
-     * aria-label for this item.
-     */
-    "aria-label"?: string;
-    /**
-     * Primary content label for this item.
-     */
-    children?: React__default.ReactNode;
-    /**
-     * If true, this item will not be selectable.
-     */
-    isDisabled?: boolean;
-}
-/**
- * Props for a Plume component that corresponds to a Section
- */
-interface SectionLikeProps {
-    /**
-     * Heading content of the title
-     */
-    title?: React__default.ReactNode;
-    /**
-     * aria-label for this section
-     */
-    "aria-label"?: string;
-    /**
-     * A list of items that belong in this group
-     */
-    children?: React__default.ReactNode;
-}
-type ItemJson = LeafItemJson | SectionJson;
-type LeafItemJson = string | {
-    value: string;
-    label?: string;
-    textValue?: string;
-    isDisabled?: boolean;
-};
-interface SectionJson {
-    title: string;
-    children: ItemJson[];
-}
-
-interface BaseMenuGroupProps extends SectionLikeProps, StyleProps {
-}
-interface MenuGroupConfig<C extends AnyPlasmicClass> {
-    noTitleVariant: PlasmicClassVariants<C>;
-    isFirstVariant: PlasmicClassVariants<C>;
-    itemsSlot: keyof PlasmicClassArgs<C>;
-    titleSlot: keyof PlasmicClassArgs<C>;
-    root: keyof PlasmicClassOverrides<C>;
-    separator: keyof PlasmicClassOverrides<C>;
-    titleContainer: keyof PlasmicClassOverrides<C>;
-    itemsContainer: keyof PlasmicClassOverrides<C>;
-}
-declare function useMenuGroup<P extends BaseMenuGroupProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: MenuGroupConfig<C>): {
-    plasmicProps: {
-        variants: PlasmicClassVariants<C>;
-        args: PlasmicClassArgs<C>;
-        overrides: PlasmicClassOverrides<C>;
-    };
-};
-
-interface BaseMenuItemProps extends ItemLikeProps {
-    /**
-     * Called when this item is selected
-     */
-    onAction?: (key: string) => void;
-}
-interface MenuItemConfig<C extends AnyPlasmicClass> {
-    isDisabledVariant?: VariantDef<PlasmicClassVariants<C>>;
-    isHighlightedVariant?: VariantDef<PlasmicClassVariants<C>>;
-    labelSlot: keyof PlasmicClassArgs<C>;
-    root: keyof PlasmicClassOverrides<C>;
-    labelContainer: keyof PlasmicClassOverrides<C>;
-}
-declare function useMenuItem<P extends BaseMenuItemProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: MenuItemConfig<C>): {
-    plasmicProps: {
-        variants: PlasmicClassVariants<C>;
-        args: PlasmicClassArgs<C>;
-        overrides: PlasmicClassOverrides<C>;
-    };
-};
-
 /*
- * Copyright 2020 Adobe. All rights reserved.
+ * 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
@@ -13731,248 +13299,131 @@ declare function useMenuItem<P extends BaseMenuItemProps, C extends AnyPlasmicCl
  * 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;
+}
 
-type Placement = 'bottom' | 'bottom left' | 'bottom right' | 'bottom start' | 'bottom end' |
-    'top' | 'top left' | 'top right' | 'top start' | 'top end' |
-    'left' | 'left top' | 'left bottom' | 'start' | 'start top' | 'start bottom' |
-    'right' | 'right top' | 'right bottom' | 'end' | 'end top' | 'end bottom';
-
-interface DropdownMenuProps {
-    /**
-     * A ReactElement that takes in a `ref` as well as the usual mouse and
-     * pointer events. The dropdown menu will be positioned relative to this
-     * trigger.
-     */
-    children: React$1.ReactElement;
-    /**
-     * The menu to show; must be either a ReactElement of Menu type, or
-     * a function that creates one if you prefer to delay creating it until
-     * the menu has been triggered.
-     */
-    menu: React$1.ReactElement<BaseMenuProps> | (() => React$1.ReactElement<BaseMenuProps>);
-    /**
-     * Where to place the menu relative to the trigger.
-     */
-    placement?: Placement;
-    /**
-     * Whether the menu is currently shown.
-     */
-    isOpen?: boolean;
-    /**
-     * Uncontrolled open state.
-     */
-    defaultOpen?: boolean;
-    /**
-     * Event handler fired when Menu's open state changes
-     */
-    onOpenChange?: (isOpen: boolean) => void;
+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;
 }
-declare function DropdownMenu(props: DropdownMenuProps): React$1.JSX.Element;
 
-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.
-     */
-    menu: React$1.ReactElement<BaseMenuProps> | (() => React$1.ReactElement<BaseMenuProps>);
-    /**
-     * Whether the button is disabled
-     */
-    isDisabled?: boolean;
-    /**
-     * Whether the menu is currently shown.
-     */
-    isOpen?: boolean;
-    /**
-     * Uncontrolled open state
-     */
-    defaultOpen?: boolean;
-    /**
-     * Event handler fired when Menu's open state changes
-     */
-    onOpenChange?: (isOpen: boolean) => void;
-    /**
-     * Desired placement location of the Select dropdown
-     */
-    placement?: Placement;
-    /**
-     * If true, menu width will always match the trigger button width.
-     * If false, then menu width will have min-width matching the
-     * trigger button width.
-     */
-    menuMatchTriggerWidth?: boolean;
-    /**
-     * If set, menu width will be exactly this width, overriding
-     * menuMatchTriggerWidth.
-     */
-    menuWidth?: number;
-}
-interface MenuButtonConfig<C extends AnyPlasmicClass> {
-    isOpenVariant: VariantDef<PlasmicClassVariants<C>>;
-    isDisabledVariant?: VariantDef<PlasmicClassVariants<C>>;
-    menuSlot: keyof PlasmicClassArgs<C>;
-    root: keyof PlasmicClassOverrides<C>;
-    trigger: keyof PlasmicClassOverrides<C>;
-}
-interface MenuButtonState {
-    open: () => void;
-    close: () => void;
-    isOpen: () => boolean;
-}
-type MenuButtonRef = React$1.Ref<MenuButtonRefValue>;
-interface MenuButtonRefValue extends MenuButtonState {
-    getRoot: () => HTMLElement | null;
-    getTrigger: () => HTMLElement | null;
-    focus: () => void;
-    blur: () => void;
+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;
 }
-declare function useMenuButton<P extends BaseMenuButtonProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: MenuButtonConfig<C>, outerRef?: MenuButtonRef): {
-    plasmicProps: {
-        variants: PlasmicClassVariants<C>;
-        args: PlasmicClassArgs<C>;
-        overrides: PlasmicClassOverrides<C>;
-    };
-    state: MenuButtonState;
+/**
+ * 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 BaseSelectProps extends DOMProps$1, AriaLabelingProps$1, FocusableDOMProps$1, InputBase$1, FocusableProps$1, StyleProps {
-    /**
-     * Key of the currently selected value
-     */
-    value?: string | null;
-    /**
-     * Event handler fired when currently selected value changes
-     */
-    onChange?: (value: string | null) => void;
-    /**
-     * Uncontrolled key of the default selected value
-     */
-    defaultValue?: string;
-    /**
-     * List of Select.Options
-     */
+interface PlumeCommonProps {
+    showStartIcon?: boolean;
+    showEndIcon?: boolean;
+    startIcon?: React$1.ReactNode;
+    endIcon?: React$1.ReactNode;
     children?: React$1.ReactNode;
-    /**
-     * List of options as an array, instead of using `children` prop. If this
-     * is passed in, then `children` is ignored.
-     *
-     * The options can be a list of strings, or a list of objects with
-     * fields `value` (for the value of the option), `label` (for what's rendered
-     * in the option), and `isDisabled` (if the option should be disabled).
-     */
-    options?: ItemJson[];
-    /**
-     * Whether the Select is currently open
-     */
-    isOpen?: boolean;
-    /**
-     * Event handler fired when Select's open state changes
-     */
-    onOpenChange?: (isOpen: boolean) => void;
-    /**
-     * Uncontrolled default open state
-     */
-    defaultOpen?: boolean;
-    /**
-     * Form name of the select element
-     */
-    name?: string;
-    /**
-     * By default, Select will render whatever is in Select.Option as the
-     * content in the trigger button when it is selected.  You can override
-     * what content by passing in `selectedContent` here.
-     */
-    selectedContent?: React$1.ReactNode;
-    /**
-     * Desired placement location of the Select dropdown
-     */
-    placement?: Placement;
-    /**
-     * If true, menu width will always match the trigger button width.
-     * If false, then menu width will have min-width matching the
-     * trigger button width.
-     */
-    menuMatchTriggerWidth?: boolean;
-    /**
-     * If set, menu width will be exactly this width, overriding
-     * menuMatchTriggerWidth.
-     */
-    menuWidth?: number;
-    /**
-     * Content to display when nothing is selected.
-     */
-    placeholder?: React$1.ReactNode;
+    isDisabled?: boolean;
 }
-type SelectRef = React$1.Ref<SelectRefValue>;
-interface SelectRefValue extends SelectState {
-    getTrigger: () => HTMLElement | null;
-    getRoot: () => HTMLElement | null;
-    focus: () => void;
-    blur: () => void;
+interface HtmlButtonProps extends Omit<React$1.ComponentProps<"button">, "ref" | "disabled"> {
 }
-interface SelectConfig<C extends AnyPlasmicClass> {
-    placeholderVariant?: VariantDef<PlasmicClassVariants<C>>;
-    isOpenVariant: VariantDef<PlasmicClassVariants<C>>;
-    isDisabledVariant?: VariantDef<PlasmicClassVariants<C>>;
-    triggerContentSlot: keyof PlasmicClassArgs<C>;
-    optionsSlot: keyof PlasmicClassArgs<C>;
-    placeholderSlot: keyof PlasmicClassArgs<C>;
-    root: keyof PlasmicClassOverrides<C>;
-    trigger: keyof PlasmicClassOverrides<C>;
-    overlay: keyof PlasmicClassOverrides<C>;
-    optionsContainer: keyof PlasmicClassOverrides<C>;
-    OptionComponent?: React$1.ComponentType<ItemLikeProps>;
-    OptionGroupComponent?: React$1.ComponentType<SectionLikeProps>;
+interface HtmlAnchorProps extends Omit<React$1.ComponentProps<"a">, "ref" | "href" | "target"> {
 }
-interface SelectState {
-    open: () => void;
-    close: () => void;
-    isOpen: () => boolean;
-    getSelectedValue: () => string | null;
-    setSelectedValue: (value: string | null) => void;
+interface PlumeActualButtonProps {
+    submitsForm?: boolean;
 }
-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 PlumeAnchorProps {
+    link?: string;
+    target?: React$1.ComponentProps<"a">["target"] | boolean;
 }
-interface SelectOptionConfig<C extends AnyPlasmicClass> {
-    isSelectedVariant: VariantDef<PlasmicClassVariants<C>>;
+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>>;
-    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>;
+    startIconSlot?: keyof PlasmicClassArgs<C>;
+    endIconSlot?: keyof PlasmicClassArgs<C>;
+    contentSlot: 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>): {
+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>;
@@ -13994,87 +13445,155 @@ declare function useSelectOptionGroup<P extends BaseSelectOptionGroupProps, C ex
 
 
 
-/**
- * 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,
+interface ToggleStateOptions extends InputBase$1 {
+  /**
+   * 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$1>,
+interface ToggleProps extends ToggleStateOptions, Validation<boolean>, FocusableProps$1 {
+  /**
+   * 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$1): T | null,
+interface AriaToggleProps extends ToggleProps, FocusableDOMProps$1, AriaLabelingProps$1, AriaValidationProps, InputDOMProps {
+  /**
+   * 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$1): Key$1 | null,
+interface AriaCheckboxProps extends CheckboxProps$1, AriaToggleProps {}
 
-  /** Get the key that comes after the given key in the collection. */
-  getKeyAfter(key: Key$1): Key$1 | null,
+interface StyleProps {
+    className?: string;
+    style?: React$1.CSSProperties;
+}
+declare function getDataProps(props: Record<string, any>): Partial<Record<string, any>>;
 
-  /** Get the first key in the collection. */
-  getFirstKey(): Key$1 | null,
+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;
+};
 
-  /** Get the last key in the collection. */
-  getLastKey(): Key$1 | null,
+/*
+ * 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.
+ */
 
-  /** 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 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
 }
 
-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,
+// A set of common DOM props that are allowed on any component
+// Ensure this is synced with DOMPropNames in filterDOMProps
+interface DOMProps {
   /**
-   * The loaded children of this node.
-   * @deprecated Use `collection.getChildren(node.key)` instead.
+   * The element's unique identifier. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/id).
    */
-  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
+  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
 }
 
 /*
- * 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
@@ -14085,7 +13604,14 @@ interface Node$1<T> {
  * governing permissions and limitations under the License.
  */
 
-type Key$1 = string | number;
+
+
+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.
@@ -14101,12 +13627,7 @@ type Key$1 = string | number;
 
 
 
-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.
@@ -14122,170 +13643,490 @@ type DisabledBehavior = 'selection' | 'all';
 
 
 
-interface Rect {
-  x: number,
-  y: number,
-  width: number,
-  height: number
+// 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
 }
 
-interface Size {
-  width: number,
-  height: number
-}
+type KeyboardEvent = BaseEvent<KeyboardEvent$2<any>>;
 
-/** 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[]
+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
 }
 
-/**
- * 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,
+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
+}
 
-  /** Get the first key in the collection. */
-  getFirstKey(): Key | null,
+interface FocusableProps<Target = Element> extends FocusEvents<Target>, KeyboardEvents {
+  /** Whether the element should receive focus on render. */
+  autoFocus?: boolean
+}
 
-  /** Get the last key in the collection. */
-  getLastKey(): Key | null,
+interface BaseMenuProps extends DOMProps, AriaLabelingProps, StyleProps {
+    /**
+     * List of `Menu.Item`s or `Menu.Group`s that make up the menu
+     */
+    children?: React$1.ReactNode;
+    /**
+     * Called with the value of a `Menu.Item` when it is selected.
+     */
+    onAction?: (value: string) => void;
+}
+type MenuRef = React$1.Ref<MenuRefValue>;
+interface MenuRefValue extends MenuState {
+    getRoot: () => HTMLElement | null;
+}
+interface MenuConfig<C extends AnyPlasmicClass> {
+    isPlacedTopVariant?: VariantDef<PlasmicClassVariants<C>>;
+    isPlacedBottomVariant?: VariantDef<PlasmicClassVariants<C>>;
+    isPlacedLeftVariant?: VariantDef<PlasmicClassVariants<C>>;
+    isPlacedRightVariant?: VariantDef<PlasmicClassVariants<C>>;
+    itemsSlot: keyof PlasmicClassArgs<C>;
+    itemsContainer: keyof PlasmicClassOverrides<C>;
+    root: keyof PlasmicClassOverrides<C>;
+}
+interface MenuState {
+    getFocusedValue: () => string | null;
+    setFocusedValue: (value: string) => void;
+}
+declare function useMenu<P extends BaseMenuProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: MenuConfig<C>, ref?: MenuRef): {
+    plasmicProps: {
+        variants: PlasmicClassVariants<C>;
+        args: PlasmicClassArgs<C>;
+        overrides: PlasmicClassOverrides<C>;
+    };
+    state: MenuState;
+};
 
-  /** Iterate over the child items of the given key. */
-  getChildren?(key: Key): Iterable<T>,
+/**
+ * In general, we try not to expose react-aria's Collections API to Plume users.
+ * The Collections API is how react-aria users pass data about collections of
+ * things using the built-in Item and Section components, which are abstract,
+ * metadata-only components that don't render anything but only serve to specify
+ * data.  For example, here's how you would use react-spectrum's Picker:
+ *
+ *   <Picker>
+ *     <Section title="Asia">
+ *       <Item key="taiwan">Taiwan</Item>
+ *       <Item key="japan">Japan</Item>
+ *       <Item key="china">China</Item>
+ *     </Section>
+ *     <Section title="Europe">
+ *       <Item key="germany">Germany</Item>
+ *       <Item key="france">France</Item>
+ *     </Section>
+ *   </Picker>
+ *
+ * You would re-use this same Item/Section components to pass similar things to
+ * Menu, Tabs, etc.
+ *
+ * For Plasmic, this API is too abstract.  The user has explicitly designed components
+ * like Select.Option and Select.OptionGroup, and it is weird that they don't actually
+ * use these components. It is more natural to do:
+ *
+ *   <Select>
+ *     <Select.OptionGroup title="Asia">
+ *       <Select.Option key="taiwan">Taiwan</Select>
+ *     </Select.OptionGroup>
+ *   </Select>
+ *
+ * For Plume, we let users directly use the components they designed, both to collect
+ * information and to perform actual rendering.  For example, for Plume,
+ * you'd use Select.Option instead of Item, and Select.OptionGroup instead of Section.
+ * This means that the Select.Option props will collect the same information Item
+ * does.
+ *
+ * A component like Select.Option then serves two purposes:
+ *
+ * 1. Allow users to specify the collection of data, like in the above example
+ *    Here, we're mainly interested in the props in those ReactElements so
+ *    we can pass the Item/Section data onto react-aria's APIs.  We are not
+ *    actually rendering these elements.
+ * 2. Once react-aria's Collections API has gone through them and built
+ *    Collection "nodes", we then create cloned versions of these elements
+ *    with the corresponding node passed in as a secret prop.  These ReactElements
+ *    are then actually used to _render_ the corresponding Option / OptionGroup.
+ *
+ * This file contains helper functions to help with implementing the above.
+ *
+ * Note also that most of the collections-based react-aria components expose
+ * a parallel API that accepts a list of "items" and a render prop, instead
+ * of list of Item/Section elements.  This is for efficiency, but we are opting
+ * to only support the composite-component pattern for now for simplicity.
+ */
 
-  /** Returns a string representation of the item's contents. */
-  getTextValue?(key: Key): string,
+/**
+ * Props for a Plume component that corresponds to an Item
+ */
+interface ItemLikeProps {
+    /**
+     * value key corresponding to this item. Not required if you use the
+     * `key` prop instead.
+     */
+    value?: string | null;
+    /**
+     * The text string value corresponding to this item. Used to support
+     * keyboard type-ahead.  If not specified, then will be derived from
+     * `children` if it is a string, or the `value` or `key`.
+     */
+    textValue?: string;
+    /**
+     * aria-label for this item.
+     */
+    "aria-label"?: string;
+    /**
+     * Primary content label for this item.
+     */
+    children?: React__default.ReactNode;
+    /**
+     * If true, this item will not be selectable.
+     */
+    isDisabled?: boolean;
+}
+/**
+ * Props for a Plume component that corresponds to a Section
+ */
+interface SectionLikeProps {
+    /**
+     * Heading content of the title
+     */
+    title?: React__default.ReactNode;
+    /**
+     * aria-label for this section
+     */
+    "aria-label"?: string;
+    /**
+     * A list of items that belong in this group
+     */
+    children?: React__default.ReactNode;
+}
+type ItemJson = LeafItemJson | SectionJson;
+type LeafItemJson = string | {
+    value: string;
+    label?: string;
+    textValue?: string;
+    isDisabled?: boolean;
+};
+interface SectionJson {
+    title: string;
+    children: ItemJson[];
+}
 
-  /** Filters the collection using the given function. */
-  UNSTABLE_filter?(filterFn: (nodeValue: string) => boolean): Collection<T>
+interface BaseMenuGroupProps extends SectionLikeProps, StyleProps {
 }
+interface MenuGroupConfig<C extends AnyPlasmicClass> {
+    noTitleVariant: PlasmicClassVariants<C>;
+    isFirstVariant: PlasmicClassVariants<C>;
+    itemsSlot: keyof PlasmicClassArgs<C>;
+    titleSlot: keyof PlasmicClassArgs<C>;
+    root: keyof PlasmicClassOverrides<C>;
+    separator: keyof PlasmicClassOverrides<C>;
+    titleContainer: keyof PlasmicClassOverrides<C>;
+    itemsContainer: keyof PlasmicClassOverrides<C>;
+}
+declare function useMenuGroup<P extends BaseMenuGroupProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: MenuGroupConfig<C>): {
+    plasmicProps: {
+        variants: PlasmicClassVariants<C>;
+        args: PlasmicClassArgs<C>;
+        overrides: 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
+interface BaseMenuItemProps extends ItemLikeProps {
+    /**
+     * Called when this item is selected
+     */
+    onAction?: (key: string) => void;
+}
+interface MenuItemConfig<C extends AnyPlasmicClass> {
+    isDisabledVariant?: VariantDef<PlasmicClassVariants<C>>;
+    isHighlightedVariant?: VariantDef<PlasmicClassVariants<C>>;
+    labelSlot: keyof PlasmicClassArgs<C>;
+    root: keyof PlasmicClassOverrides<C>;
+    labelContainer: keyof PlasmicClassOverrides<C>;
+}
+declare function useMenuItem<P extends BaseMenuItemProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: MenuItemConfig<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.
+ */
+
+
+
+type Placement = 'bottom' | 'bottom left' | 'bottom right' | 'bottom start' | 'bottom end' |
+    'top' | 'top left' | 'top right' | 'top start' | 'top end' |
+    'left' | 'left top' | 'left bottom' | 'start' | 'start top' | 'start bottom' |
+    'right' | 'right top' | 'right bottom' | 'end' | 'end top' | 'end bottom';
+
+interface DropdownMenuProps {
+    /**
+     * A ReactElement that takes in a `ref` as well as the usual mouse and
+     * pointer events. The dropdown menu will be positioned relative to this
+     * trigger.
+     */
+    children: React$1.ReactElement;
+    /**
+     * The menu to show; must be either a ReactElement of Menu type, or
+     * a function that creates one if you prefer to delay creating it until
+     * the menu has been triggered.
+     */
+    menu: React$1.ReactElement<BaseMenuProps> | (() => React$1.ReactElement<BaseMenuProps>);
+    /**
+     * Where to place the menu relative to the trigger.
+     */
+    placement?: Placement;
+    /**
+     * Whether the menu is currently shown.
+     */
+    isOpen?: boolean;
+    /**
+     * Uncontrolled open state.
+     */
+    defaultOpen?: boolean;
+    /**
+     * Event handler fired when Menu's open state changes
+     */
+    onOpenChange?: (isOpen: boolean) => void;
+}
+declare function DropdownMenu(props: DropdownMenuProps): React$1.JSX.Element;
+
+interface BaseMenuButtonProps extends DOMProps, FocusableProps, 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.
+     */
+    menu: React$1.ReactElement<BaseMenuProps> | (() => React$1.ReactElement<BaseMenuProps>);
+    /**
+     * Whether the button is disabled
+     */
+    isDisabled?: boolean;
+    /**
+     * Whether the menu is currently shown.
+     */
+    isOpen?: boolean;
+    /**
+     * Uncontrolled open state
+     */
+    defaultOpen?: boolean;
+    /**
+     * Event handler fired when Menu's open state changes
+     */
+    onOpenChange?: (isOpen: boolean) => void;
+    /**
+     * Desired placement location of the Select dropdown
+     */
+    placement?: Placement;
+    /**
+     * If true, menu width will always match the trigger button width.
+     * If false, then menu width will have min-width matching the
+     * trigger button width.
+     */
+    menuMatchTriggerWidth?: boolean;
+    /**
+     * If set, menu width will be exactly this width, overriding
+     * menuMatchTriggerWidth.
+     */
+    menuWidth?: number;
+}
+interface MenuButtonConfig<C extends AnyPlasmicClass> {
+    isOpenVariant: VariantDef<PlasmicClassVariants<C>>;
+    isDisabledVariant?: VariantDef<PlasmicClassVariants<C>>;
+    menuSlot: keyof PlasmicClassArgs<C>;
+    root: keyof PlasmicClassOverrides<C>;
+    trigger: keyof PlasmicClassOverrides<C>;
+}
+interface MenuButtonState {
+    open: () => void;
+    close: () => void;
+    isOpen: () => boolean;
+}
+type MenuButtonRef = React$1.Ref<MenuButtonRefValue>;
+interface MenuButtonRefValue extends MenuButtonState {
+    getRoot: () => HTMLElement | null;
+    getTrigger: () => HTMLElement | null;
+    focus: () => void;
+    blur: () => void;
+}
+declare function useMenuButton<P extends BaseMenuButtonProps, C extends AnyPlasmicClass>(plasmicClass: C, props: P, config: MenuButtonConfig<C>, outerRef?: MenuButtonRef): {
+    plasmicProps: {
+        variants: PlasmicClassVariants<C>;
+        args: PlasmicClassArgs<C>;
+        overrides: PlasmicClassOverrides<C>;
+    };
+    state: MenuButtonState;
+};
+
+interface BaseSelectProps extends DOMProps, AriaLabelingProps, FocusableDOMProps, InputBase, FocusableProps, StyleProps {
+    /**
+     * Key of the currently selected value
+     */
+    value?: string | null;
+    /**
+     * Event handler fired when currently selected value changes
+     */
+    onChange?: (value: string | null) => void;
+    /**
+     * Uncontrolled key of the default selected value
+     */
+    defaultValue?: string;
+    /**
+     * List of Select.Options
+     */
+    children?: React$1.ReactNode;
+    /**
+     * List of options as an array, instead of using `children` prop. If this
+     * is passed in, then `children` is ignored.
+     *
+     * The options can be a list of strings, or a list of objects with
+     * fields `value` (for the value of the option), `label` (for what's rendered
+     * in the option), and `isDisabled` (if the option should be disabled).
+     */
+    options?: ItemJson[];
+    /**
+     * Whether the Select is currently open
+     */
+    isOpen?: boolean;
+    /**
+     * Event handler fired when Select's open state changes
+     */
+    onOpenChange?: (isOpen: boolean) => void;
+    /**
+     * Uncontrolled default open state
+     */
+    defaultOpen?: boolean;
+    /**
+     * Form name of the select element
+     */
+    name?: string;
+    /**
+     * By default, Select will render whatever is in Select.Option as the
+     * content in the trigger button when it is selected.  You can override
+     * what content by passing in `selectedContent` here.
+     */
+    selectedContent?: React$1.ReactNode;
+    /**
+     * Desired placement location of the Select dropdown
+     */
+    placement?: Placement;
+    /**
+     * If true, menu width will always match the trigger button width.
+     * If false, then menu width will have min-width matching the
+     * trigger button width.
+     */
+    menuMatchTriggerWidth?: boolean;
+    /**
+     * If set, menu width will be exactly this width, overriding
+     * menuMatchTriggerWidth.
+     */
+    menuWidth?: number;
+    /**
+     * Content to display when nothing is selected.
+     */
+    placeholder?: React$1.ReactNode;
+}
+type SelectRef = React$1.Ref<SelectRefValue>;
+interface SelectRefValue extends SelectState {
+    getTrigger: () => HTMLElement | null;
+    getRoot: () => HTMLElement | null;
+    focus: () => void;
+    blur: () => void;
 }
-
-/*
- * 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 SelectConfig<C extends AnyPlasmicClass> {
+    placeholderVariant?: VariantDef<PlasmicClassVariants<C>>;
+    isOpenVariant: VariantDef<PlasmicClassVariants<C>>;
+    isDisabledVariant?: VariantDef<PlasmicClassVariants<C>>;
+    triggerContentSlot: keyof PlasmicClassArgs<C>;
+    optionsSlot: keyof PlasmicClassArgs<C>;
+    placeholderSlot: keyof PlasmicClassArgs<C>;
+    root: keyof PlasmicClassOverrides<C>;
+    trigger: keyof PlasmicClassOverrides<C>;
+    overlay: keyof PlasmicClassOverrides<C>;
+    optionsContainer: keyof PlasmicClassOverrides<C>;
+    OptionComponent?: React$1.ComponentType<ItemLikeProps>;
+    OptionGroupComponent?: React$1.ComponentType<SectionLikeProps>;
 }
-
-interface LongPressEvent extends Omit<PressEvent, 'type' | 'continuePropagation'> {
-  /** The type of long press event being fired. */
-  type: 'longpressstart' | 'longpressend' | 'longpress'
+interface SelectState {
+    open: () => void;
+    close: () => void;
+    isOpen: () => boolean;
+    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;
+};
 
-/*
- * 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.
- */
+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>;
+    };
+};
 
-type Key = string | number;
+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>;
+    };
+};
 
 interface FocusState {
     /** Whether the collection is currently focused. */
@@ -14295,9 +14136,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 | null;
+    readonly childFocusStrategy: FocusStrategy$1 | 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): void;
+    setFocusedKey(key: Key | null, child?: FocusStrategy$1): void;
 }
 interface MultipleSelectionState extends FocusState {
     /** The type of selection that is allowed in the collection. */
@@ -14413,11 +14254,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 | null;
+    get childFocusStrategy(): FocusStrategy$1 | null;
     /**
      * Sets the focused key.
      */
-    setFocusedKey(key: Key | null, childFocusStrategy?: FocusStrategy): void;
+    setFocusedKey(key: Key | null, childFocusStrategy?: FocusStrategy$1): void;
     /**
      * The currently selected keys in the collection.
      */
@@ -14485,9 +14326,9 @@ declare class SelectionManager implements MultipleSelectionManager {
 
 interface ListState<T> {
     /** A collection of items in the list. */
-    collection: Collection$1<Node$1<T>>;
+    collection: Collection<Node<T>>;
     /** A set of items that are disabled. */
-    disabledKeys: Set<Key$1>;
+    disabledKeys: Set<Key>;
     /** A selection manager to read and update multiple selection state. */
     selectionManager: SelectionManager;
 }
@@ -14508,137 +14349,7 @@ 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 {
+interface SwitchBase extends InputBase$1, FocusableProps$1 {
   /**
    * The content to render as the Switch's label.
    */
@@ -14661,7 +14372,7 @@ interface SwitchBase extends InputBase, FocusableProps {
   value?: string
 }
 interface SwitchProps$1 extends SwitchBase {}
-interface AriaSwitchBase extends SwitchBase, FocusableDOMProps, InputDOMProps, AriaLabelingProps {
+interface AriaSwitchBase extends SwitchBase, FocusableDOMProps$1, InputDOMProps, AriaLabelingProps$1 {
   /**
    * Identifies the element (or elements) whose contents or presence are controlled by the current element.
    */
@@ -14742,7 +14453,7 @@ declare function useTextInput<P extends PlumeTextInputProps, C extends AnyPlasmi
     };
 };
 
-interface BaseTriggeredOverlayProps extends StyleProps, DOMProps$1 {
+interface BaseTriggeredOverlayProps extends StyleProps, DOMProps {
     children?: React$1.ReactNode;
 }
 interface TriggeredOverlayConfig<C extends AnyPlasmicClass> {
@@ -14778,7 +14489,7 @@ interface OverlayTriggerState {
 interface TriggeredOverlayContextValue {
     triggerRef: React$1.RefObject<HTMLElement>;
     state: OverlayTriggerState;
-    autoFocus?: boolean | FocusStrategy$1;
+    autoFocus?: boolean | FocusStrategy;
     placement?: Placement;
     overlayMatchTriggerWidth?: boolean;
     overlayMinTriggerWidth?: boolean;