@accelint/design-system 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -1,10 +1,873 @@
+import * as react from 'react';
+import { RefAttributes, Context, PropsWithChildren, JSX, ReactHTML, ReactElement, MouseEvent, ReactNode, ForwardedRef, RefObject, RefCallback, CSSProperties } from 'react';
+import * as react_aria_components from 'react-aria-components';
+import { ContextValue, SectionProps, SelectValueProps, CollectionRenderer, SlotProps, InputProps as InputProps$1, NumberFieldRenderProps, TextAreaProps as TextAreaProps$1, TextFieldRenderProps } from 'react-aria-components';
+import { B as ButtonProps, R as RenderPropsChildren, a as ButtonRenderProps, b as ButtonColors, c as ButtonMapping, d as ButtonSizes, e as ButtonVariants, L as LinkButtonProps, T as ToggleButtonProps, C as CheckboxProps, f as CheckboxRenderProps, g as CheckboxClassNames, h as CheckboxAlignment, i as CheckboxGroupProps, j as CheckboxGroupRenderProps, k as ChipProps, l as ChipItemProps, m as BaseChipProps, n as ChipListProps, o as ChipGroupProps, P as ProviderValues, p as ComboBoxProps, q as ComboBoxClassNames, r as ComboBoxMapping, s as ComboBoxSizes, D as DialogProps, t as DialogRenderProps, u as DialogMapping, v as DialogSizes, w as DrawerProps, x as DrawerTabListProps, y as DrawerTabProps, z as DrawerClassNames, A as DrawerMapping, G as GroupProps, E as BaseGroupProps, I as IconProps, F as IconSizes, H as InputProps, J as BaseInputProps, M as MenuProps, K as MenuClassNames, N as MenuMapping, O as MenuSizes, Q as MenuListProps, S as MenuItemProps, U as NumberFieldProps, V as NumberFieldClassNames, W as NumberFieldMapping, X as NumberFieldSizes, Y as OptionsProps, Z as OptionsClassNames, _ as OptionsMapping, $ as OptionsSizes, a0 as OptionsListProps, a1 as OptionsItemProps, a2 as PickerProps, a3 as PickerItemProps, a4 as PickerClassNames, a5 as PopoverProps, a6 as PopoverRenderProps, a7 as PopoverClassNames, a8 as PopoverMapping, a9 as QueryBuilderContextValue, aa as QueryBuilderProps, ab as RadioContextProps, ac as RadioRenderProps, ad as RadioClassNames, ae as RadioAlignment, af as RadioGroupProps, ag as SearchFieldProps, ah as SearchFieldClassNames, ai as SearchFieldMapping, aj as InputSize, ak as SearchFieldVariants, al as SelectProps, am as SelectClassNames, an as SelectMapping, ao as SelectSizes, ap as SwitchProps, aq as BaseSwitchProps, ar as TabsProps, as as TabsClassNames, at as TabListProps, au as TabListAlignment, av as TabListAnchor, aw as TabListSizes, ax as TabListVariants, ay as TabPanelsProps, az as TabPanelProps, aA as TextAreaProps, aB as BaseTextAreaProps, aC as TextFieldProps, aD as TextFieldClassNames, aE as TextFieldMapping, aF as TextFieldSizes, aG as TooltipProps, aH as TooltipClassNames, aI as TooltipMapping, aJ as TooltipRenderProps, aK as TooltipTargetProps, aL as TreeStateContextValue, aM as TreeProps, aN as TreeGroupProps, aO as TreeItemProps, aP as RadioProps, aQ as TabProps, aR as OmitProtectedProps, aS as ButtonClassNames, aT as ChipClassNames, aU as DialogClassNames, aV as GroupClassNames, aW as IconClassNames, aX as InputClassNames, aY as QueryBuilderClassNames, aZ as SwitchClassNames, a_ as TextAreaClassNames, a$ as TreeClassNames, b0 as ClassNames, b1 as AsType, b2 as RGBA, b3 as Contract, b4 as computeContract, b5 as UseTreeOptions, b6 as UseTreeResult } from './vanilla-DUNpoS8t.js';
+export { d9 as ButtonState, da as CheckboxGroupState, db as CheckboxState, eP as ChildrenRenderProps, dc as ChipColors, dd as ChipMapping, de as ChipRenderProps, df as ChipSizes, dg as ChipState, eQ as ClassNameRenderProps, dh as ComboBoxRenderProps, di as ComboBoxState, eR as CssVarFunction, dj as DialogState, dk as DrawerAnchor, dl as DrawerDialogProps, dm as DrawerDialogState, dn as DrawerRenderProps, dp as DrawerState, dq as DrawerTabRenderProps, dr as GroupState, ds as IconState, dt as InputMapping, du as InputRenderProps, dv as InputState, dw as InputType, eS as MapLeafNodes, dx as MenuItemRenderProps, dy as MenuItemState, dz as MenuState, dA as NumberFieldState, dB as OptionsItemState, dC as OptionsListState, dD as OptionsState, eT as PartialMapLeafNodes, dE as PickerItemRenderProps, dF as PickerItemState, dG as PickerState, dH as PopoverState, eU as Primitive, eV as ProviderValue, dI as QueryBuilderGroupState, dJ as QueryBuilderMapping, dK as QueryBuilderRuleState, dL as QueryBuilderSizes, dM as QueryBuilderState, dN as QueryBuilderValueEditors, dO as RadioGroupState, dP as RadioState, eW as RenderProps, eX as RenderPropsClassName, eY as RenderPropsStyle, dQ as SearchFieldRenderProps, dR as SearchFieldState, dS as SelectRenderProps, dT as SelectState, eZ as StylePropRenderProps, e_ as StyleRenderProps, dU as SwitchAlignment, dV as SwitchRenderProps, dW as SwitchState, dX as TabListState, dY as TabPanelRenderProps, dZ as TabPanelState, d_ as TabPanelsState, d$ as TabRenderProps, e0 as TabState, e1 as TextAreaRenderProps, e2 as TextAreaState, e3 as TextFieldState, e4 as TooltipState, e5 as TooltipTargetState, e$ as TreeActions, f0 as TreeGroupNode, e6 as TreeGroupRenderProps, e7 as TreeGroupState, e8 as TreeIndicatorRenderProps, e9 as TreeIndicatorState, f1 as TreeItemNode, ea as TreeItemRenderProps, eb as TreeItemState, ec as TreeMapping, f2 as TreeNode, f3 as TreeNodes, ed as TreeRenderProps, ee as TreeSizes, ef as TreeState, f4 as applyThemeVars, f5 as assignPartialVars, eg as bodies, b7 as buttonClassNames, b8 as buttonColorVars, b9 as buttonContainer, ba as buttonSpaceVars, bb as buttonStateVars, bc as checkboxClassNames, bd as checkboxColorVars, be as checkboxContainer, bf as checkboxGroupStateVars, bg as checkboxSpaceVars, bh as checkboxStateVars, bi as chipClassNames, bj as chipColorVars, bk as chipContainer, bl as chipSpaceVars, bm as chipStateVars, bn as comboBoxClassNames, bo as comboBoxColorVars, bp as comboBoxContainer, bq as comboBoxSpaceVars, br as comboBoxStateVars, f6 as containerQueries, f7 as containerQuery, eh as defaultElevationVarValues, ei as defaultElevations, ej as defaultFocus, ek as defaultFocusVarValues, el as defaultGenericColorVarValues, em as defaultGenericColors, en as defaultRadius, eo as defaultRadiusVarValues, ep as defaultSemanticColorVarValues, eq as defaultSemanticColors, er as defaultSizes, es as defaultSizesVarValues, et as defaultSpace, eu as defaultSpaceVarValues, ev as defaultTypography, ew as defaultTypographyVarValues, ex as defaultZIndex, ey as defaultZIndexVarValues, bs as dialogClassNames, bt as dialogColorVars, bu as dialogContainer, bv as dialogSpaceVars, bw as dialogStateVars, bx as drawerAnimationVars, by as drawerClassNames, bz as drawerColorVars, bA as drawerContainer, bB as drawerDialogStateVars, bC as drawerSpaceVars, bD as drawerStateVars, ez as elevationVars, eA as families, eB as focusOutlineStyle, eC as focusVars, eD as genericColorVars, bE as groupClassNames, bF as groupContainer, bG as groupSpaceVars, bH as groupStateVars, eE as headings, bI as iconClassNames, bJ as iconColorVars, bK as iconContainer, bL as iconSpaceVars, bM as iconStateVars, f8 as inlineVars, bN as inputClassNames, bO as inputColorVars, bP as inputContainer, bQ as inputSpaceVars, bR as inputStateVars, eF as inputs, eG as label, eH as layers, bS as menuColorVars, bT as menuItemStateVars, bU as menuSpaceVars, bV as menuStateVars, bW as numberFieldClassNames, bX as numberFieldColorVars, bY as numberFieldContainer, bZ as numberFieldSpaceVars, b_ as numberFieldStateVars, b$ as optionsClassNames, c0 as optionsColorVars, c1 as optionsContainers, c2 as optionsItemStateVars, c3 as optionsListStateVars, c4 as optionsSpaceVars, c5 as optionsStateVars, c6 as pickerClassNames, c7 as pickerContainers, c8 as pickerItemColorVars, c9 as pickerItemStateVars, ca as pickerSpaceVars, cb as pickerStateVars, cc as popoverClassNames, cd as popoverColorVars, ce as popoverSpaceVars, cf as popoverStateVars, cg as queryBuilderClassNames, ch as queryBuilderColorVars, ci as queryBuilderContainers, cj as queryBuilderGroupStateVars, ck as queryBuilderRuleStateVars, cl as queryBuilderSpaceVars, cm as queryBuilderStateVars, cn as radioClassNames, co as radioColorVars, cp as radioGroupStateVars, cq as radioSpaceVars, cr as radioStateVars, eI as radiusVars, cs as searchFieldClassNames, ct as searchFieldContainer, cu as searchFieldSpaceVars, cv as searchFieldStateVars, cw as selectClassNames, cx as selectColorVars, cy as selectContainer, cz as selectSpaceVars, cA as selectStateVars, eJ as semanticColorVars, eK as sizeVars, eL as spaceVars, eM as surfaces, cB as switchClassNames, cC as switchColorVars, cD as switchContainer, cE as switchSpaceVars, cF as switchStateVars, cG as tabColorVars, cH as tabListStateVars, cI as tabPanelStateVars, cJ as tabPanelsStateVars, cK as tabSpaceVars, cL as tabStateVars, cM as tabsClassNames, cN as tabsContainers, cO as textAreaClassNames, cP as textAreaColorVars, cQ as textAreaContainer, cR as textAreaSpaceVars, cS as textAreaStateVars, cT as textFieldClassNames, cU as textFieldColorVars, cV as textFieldContainer, cW as textFieldSpaceVars, cX as textFieldStateVars, cY as tooltipClassNames, cZ as tooltipContainers, c_ as tooltipSpaceVars, c$ as tooltipStateVars, d0 as tooltipTargetStateVars, d1 as treeClassNames, d2 as treeColorVars, d3 as treeContainers, d4 as treeGroupStateVars, d5 as treeIndicatorStateVars, d6 as treeItemStateVars, d7 as treeSpaceVars, d8 as treeStateVars, eN as typographyVars, f9 as unwrapCssVar, eO as zIndexVars } from './vanilla-DUNpoS8t.js';
+import * as react_aria from 'react-aria';
+import { PressEvent, PressHookProps } from 'react-aria';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Collection, Node } from 'react-stately';
+import * as _react_types_shared from '@react-types/shared';
+import { ItemDropTarget } from '@react-types/shared';
+import { z } from 'zod';
+import 'type-fest';
+import 'react-querybuilder';
+import '@vanilla-extract/css';
+
+declare const AriaFieldError: (props: react_aria_components.FieldErrorProps & RefAttributes<HTMLElement>) => react.ReactElement | null;
+declare const AriaFieldErrorContext: react.Context<ContextValue<react_aria_components.FieldErrorProps & RefAttributes<HTMLElement>, HTMLElement>>;
+declare const AriaGroup: (props: react_aria_components.GroupProps & RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+declare const AriaGroupContext: react.Context<ContextValue<react_aria_components.GroupProps & RefAttributes<HTMLDivElement>, HTMLDivElement>>;
+declare const AriaHeader: (props: react.HTMLAttributes<HTMLElement> & RefAttributes<object> & RefAttributes<HTMLElement>) => react.ReactElement | null;
+declare const AriaHeaderContext: react.Context<ContextValue<react.HTMLAttributes<HTMLElement> & RefAttributes<object>, HTMLElement>>;
+declare const AriaHeading: (props: react_aria_components.HeadingProps & RefAttributes<HTMLHeadingElement>) => react.ReactElement | null;
+declare const AriaHeadingContext: react.Context<ContextValue<react_aria_components.HeadingProps & RefAttributes<HTMLHeadingElement>, HTMLHeadingElement>>;
+declare const AriaKeyboard: (props: react.HTMLAttributes<HTMLElement> & RefAttributes<HTMLElement>) => react.ReactElement | null;
+declare const AriaKeyboardContext: react.Context<ContextValue<react.HTMLAttributes<HTMLElement> & RefAttributes<HTMLElement>, HTMLElement>>;
+declare const AriaLabel: (props: react_aria_components.LabelProps & RefAttributes<HTMLLabelElement>) => react.ReactElement | null;
+declare const AriaLabelContext: react.Context<ContextValue<react_aria_components.LabelProps & RefAttributes<HTMLLabelElement>, HTMLLabelElement>>;
+declare const AriaSeparator: (props: react_aria_components.SeparatorProps & RefAttributes<object> & RefAttributes<HTMLElement>) => react.ReactElement | null;
+declare const AriaSeparatorContext: react.Context<ContextValue<react_aria_components.SeparatorProps & RefAttributes<object>, HTMLElement>>;
+declare const AriaText: (props: react_aria_components.TextProps & RefAttributes<HTMLElement>) => react.ReactElement | null;
+declare const AriaTextContext: react.Context<ContextValue<react_aria_components.TextProps & RefAttributes<HTMLElement>, HTMLElement>>;
 /**
- * THIS IS A GENERATED FILE. DO NOT ALTER DIRECTLY.
+ * Due to the complexity of types and technical constraints of TS, it's not
+ * possible for the above wrapping utility to support components that accept
+ * generic parameters. This means that these components must be manually wrapped
  */
-export { AriaFieldError, AriaFieldErrorContext, AriaGroup, AriaGroupContext, AriaHeader, AriaHeaderContext, AriaHeading, AriaHeadingContext, AriaKeyboard, AriaKeyboardContext, AriaLabel, AriaLabelContext, AriaSection, AriaSectionContext, AriaSelectValue, AriaSelectValueContext, AriaSeparator, AriaSeparatorContext, AriaText, AriaTextContext, Button, ButtonContext, Checkbox, CheckboxContext, CheckboxGroup, CheckboxGroupContext, Chip, ChipContext, ChipGroup, ChipGroupContext, ChipItem, ChipList, ComboBox, ComboBoxContext, Dialog, DialogContext, Drawer, DrawerDialog, DrawerTab, DrawerTabList, Element, ElementContext, Group, GroupContext, Icon, IconContext, Input, InputContext, LinkButton, LinkButtonContext, Menu, MenuContext, MenuItem, MenuItemContext, MenuList, MenuListContext, MergeProvider, Options, OptionsContext, OptionsItem, OptionsItemContext, OptionsList, OptionsListContext, Picker, PickerContext, PickerItem, PickerItemContext, Popover, PopoverContext, QueryBuilder, QueryBuilderContext, Radio, RadioContext, RadioGroup, RadioGroupContext, SearchField, SearchFieldContext, Select, SelectContext, Switch, SwitchContext, Tab, TabContext, TabList, TabListContext, TabPanel, TabPanelContext, TabPanels, TabPanelsContext, Tabs, TabsContext, TextArea, TextAreaContext, ToggleButton, ToggleButtonContext, Tooltip, TooltipContext, TooltipTarget, TooltipTargetContext, Tree, TreeGroup, TreeItem, TreeStateContext, buttonClassNames, buttonColorVars, buttonContainer, buttonSpaceVars, buttonStateVars, checkboxClassNames, checkboxColorVars, checkboxContainer, checkboxGroupStateVars, checkboxSpaceVars, checkboxStateVars, chipClassNames, chipColorVars, chipContainer, chipSpaceVars, chipStateVars, comboBoxClassNames, comboBoxColorVars, comboBoxContainer, comboBoxSpaceVars, comboBoxStateVars, createCollectionRenderer, dialogClassNames, dialogColorVars, dialogContainer, dialogSpaceVars, dialogStateVars, drawerAnimationVars, drawerClassNames, drawerColorVars, drawerContainer, drawerDialogStateVars, drawerSpaceVars, drawerStateVars, groupClassNames, groupContainer, groupSpaceVars, groupStateVars, iconClassNames, iconColorVars, iconContainer, iconSpaceVars, iconStateVars, inputClassNames, inputColorVars, inputContainer, inputSpaceVars, inputStateVars, menuColorVars, menuItemStateVars, menuSpaceVars, menuStateVars, optionsClassNames, optionsColorVars, optionsContainers, optionsItemStateVars, optionsListStateVars, optionsSpaceVars, optionsStateVars, pickerClassNames, pickerContainers, pickerItemColorVars, pickerItemStateVars, pickerSpaceVars, pickerStateVars, popoverClassNames, popoverColorVars, popoverSpaceVars, popoverStateVars, pressToMouseEvent, queryBuilderClassNames, queryBuilderColorVars, queryBuilderContainers, queryBuilderGroupStateVars, queryBuilderRuleStateVars, queryBuilderSpaceVars, queryBuilderStateVars, radioClassNames, radioColorVars, radioGroupStateVars, radioSpaceVars, radioStateVars, searchFieldClassNames, searchFieldContainer, searchFieldSpaceVars, searchFieldStateVars, selectClassNames, selectColorVars, selectContainer, selectSpaceVars, selectStateVars, switchClassNames, switchColorVars, switchContainer, switchSpaceVars, switchStateVars, tabColorVars, tabListStateVars, tabPanelStateVars, tabPanelsStateVars, tabSpaceVars, tabStateVars, tabsClassNames, tabsContainers, textAreaClassNames, textAreaColorVars, textAreaContainer, textAreaSpaceVars, textAreaStateVars, tooltipClassNames, tooltipContainers, tooltipSpaceVars, tooltipStateVars, tooltipTargetStateVars, treeClassNames, treeColorVars, treeContainers, treeGroupStateVars, treeIndicatorStateVars, treeItemStateVars, treeSpaceVars, treeStateVars, } from './components';
-export type { ButtonClassNames, ButtonColors, ButtonMapping, ButtonProps, ButtonRenderProps, ButtonSizes, ButtonState, CheckboxAlignment, CheckboxClassNames, CheckboxGroupProps, CheckboxGroupRenderProps, CheckboxGroupState, CheckboxProps, CheckboxRenderProps, CheckboxState, ChipClassNames, ChipColors, ChipGroupProps, ChipItemProps, ChipListProps, ChipMapping, ChipProps, ChipRenderProps, ChipSizes, ChipState, ComboBoxClassNames, ComboBoxMapping, ComboBoxProps, ComboBoxRenderProps, ComboBoxSizes, ComboBoxState, DialogClassNames, DialogMapping, DialogProps, DialogRenderProps, DialogSizes, DialogState, DrawerAnchor, DrawerClassNames, DrawerDialogProps, DrawerDialogState, DrawerMapping, DrawerProps, DrawerRenderProps, DrawerState, DrawerTabListProps, DrawerTabProps, DrawerTabRenderProps, ElementProps, GroupClassNames, GroupProps, GroupState, IconClassNames, IconProps, IconSizes, IconState, InputClassNames, InputMapping, InputProps, InputRenderProps, InputState, InputType, LinkButtonProps, MenuClassNames, MenuItemProps, MenuItemRenderProps, MenuItemState, MenuListProps, MenuMapping, MenuProps, MenuSizes, MenuState, MergeProviderProps, OptionsClassNames, OptionsItemProps, OptionsItemState, OptionsListProps, OptionsListState, OptionsMapping, OptionsProps, OptionsSizes, OptionsState, PickerClassNames, PickerItemProps, PickerItemRenderProps, PickerItemState, PickerProps, PickerState, PopoverClassNames, PopoverProps, PopoverState, QueryBuilderClassNames, QueryBuilderContextValue, QueryBuilderGroupState, QueryBuilderMapping, QueryBuilderProps, QueryBuilderRuleState, QueryBuilderSizes, QueryBuilderState, QueryBuilderValueEditors, RadioAlignment, RadioClassNames, RadioGroupProps, RadioGroupState, RadioProps, RadioState, SearchFieldClassNames, SearchFieldMapping, SearchFieldProps, SearchFieldRenderProps, SearchFieldState, SelectClassNames, SelectMapping, SelectProps, SelectRenderProps, SelectState, SwitchAlignment, SwitchClassNames, SwitchProps, SwitchRenderProps, SwitchState, TabListAlignment, TabListAnchor, TabListProps, TabListState, TabListVariants, TabPanelProps, TabPanelRenderProps, TabPanelState, TabPanelsProps, TabPanelsState, TabProps, TabRenderProps, TabState, TabsClassNames, TabsProps, TextAreaClassNames, TextAreaProps, TextAreaRenderProps, TextAreaState, ToggleButtonProps, TooltipClassNames, TooltipMapping, TooltipProps, TooltipRenderProps, TooltipState, TooltipTargetProps, TooltipTargetState, TreeClassNames, TreeGroupProps, TreeGroupRenderProps, TreeGroupState, TreeIndicatorRenderProps, TreeIndicatorState, TreeItemProps, TreeItemRenderProps, TreeItemState, TreeMapping, TreeProps, TreeRenderProps, TreeSizes, TreeState, TreeStateContextValue, } from './components';
-export { DefaultsProvider, ThemeProvider, useCollectionRender, useContextProps, useDefaultProps, useDefaults, usePropagatingPress, useSlot, useTheme, useTree, useUpdateEffect, } from './hooks';
-export type { DefaultsContext, DefaultsProviderProps, ThemeContext, ThemeVars, } from './hooks';
-export { bodies, defaultElevationVarValues, defaultElevations, defaultFocus, defaultFocusVarValues, defaultGenericColorVarValues, defaultGenericColors, defaultRadius, defaultRadiusVarValues, defaultSemanticColorVarValues, defaultSemanticColors, defaultSizes, defaultSizesVarValues, defaultSpace, defaultSpaceVarValues, defaultTypography, defaultTypographyVarValues, defaultZIndex, defaultZIndexVarValues, elevationVars, families, focusOutlineStyle, focusVars, genericColorVars, headings, inputs, label, layers, radiusVars, semanticColorVars, sizeVars, spaceVars, surfaces, typographyVars, zIndexVars, } from './styles';
-export type { AsType, ChildrenRenderProps, ClassNameRenderProps, ClassNames, Contract, CssVarFunction, MapLeafNodes, OmitProtectedProps, PartialMapLeafNodes, Primitive, ProviderValue, ProviderValues, RGBA, RenderProps, RenderPropsChildren, RenderPropsClassName, RenderPropsStyle, StylePropRenderProps, StyleRenderProps, TreeActions, TreeGroupNode, TreeItemNode, TreeNode, TreeNodes, UseTreeOptions, UseTreeResult, } from './types';
-export { alphaChannelAsNumberValidator, alphaChannelAsStringValidator, applyThemeVars, assignPartialVars, callRenderProps, colorChannelAsNumberValidator, colorChannelAsStringValidator, computeContract, containerQueries, containerQuery, continuePropagation, inlineVars, mergeClassNames, mergeProps, pixelValueAsNumberValidator, pixelValueAsStringValidator, rgbaAsStringValidator, rgbaAsTupleValidator, unwrapCssVar, wrapRenderProps, } from './utils';
+declare const AriaSectionContext: react.Context<ContextValue<SectionProps<object>, HTMLElement>>;
+declare const AriaSection: <T extends object>(props: SectionProps<T> & RefAttributes<HTMLElement>) => react.ReactElement | null;
+declare const AriaSelectValueContext: react.Context<ContextValue<SelectValueProps<object>, HTMLSpanElement>>;
+declare const AriaSelectValue: <T extends object>(props: SelectValueProps<T> & RefAttributes<HTMLSpanElement>) => react.ReactElement | null;
+
+declare const ButtonContext: Context<ContextValue<ButtonProps, HTMLButtonElement>>;
+declare const Button: (props: Omit<react_aria_components.ButtonProps, "children" | "className" | "style"> & {
+    children?: RenderPropsChildren<ButtonRenderProps>;
+    classNames?: Partial<{
+        container: string;
+        button: string;
+    }> | undefined;
+    color?: ButtonColors;
+    mapping?: Partial<ButtonMapping>;
+    size?: ButtonSizes;
+    variant?: ButtonVariants;
+} & react.RefAttributes<HTMLButtonElement>) => react.ReactElement | null;
+declare const LinkButtonContext: Context<ContextValue<LinkButtonProps, HTMLAnchorElement>>;
+declare const LinkButton: (props: Omit<react_aria_components.LinkProps, "children" | "className" | "style"> & {
+    children?: RenderPropsChildren<ButtonRenderProps>;
+    classNames?: Partial<{
+        container: string;
+        button: string;
+    }> | undefined;
+    color?: ButtonColors;
+    mapping?: Partial<ButtonMapping>;
+    size?: ButtonSizes;
+    variant?: ButtonVariants;
+} & react.RefAttributes<HTMLAnchorElement>) => react.ReactElement | null;
+declare const ToggleButtonContext: Context<ContextValue<ToggleButtonProps, HTMLButtonElement>>;
+declare const ToggleButton: (props: Omit<react_aria_components.ToggleButtonProps, "children" | "className" | "style"> & {
+    children?: RenderPropsChildren<ButtonRenderProps>;
+    classNames?: Partial<{
+        container: string;
+        button: string;
+    }> | undefined;
+    color?: ButtonColors;
+    mapping?: Partial<ButtonMapping>;
+    size?: ButtonSizes;
+    variant?: ButtonVariants;
+} & react.RefAttributes<HTMLButtonElement>) => react.ReactElement | null;
+
+declare const CheckboxContext: react.Context<ContextValue<CheckboxProps, HTMLLabelElement>>;
+declare const Checkbox: (props: Omit<react_aria_components.CheckboxProps, "children" | "className" | "style"> & {
+    children?: RenderPropsChildren<CheckboxRenderProps>;
+    label?: string;
+    classNames?: CheckboxClassNames;
+    alignInput?: CheckboxAlignment;
+} & react.RefAttributes<HTMLLabelElement>) => react.ReactElement | null;
+declare const CheckboxGroupContext: react.Context<ContextValue<CheckboxGroupProps, HTMLDivElement>>;
+declare const CheckboxGroup: (props: Omit<react_aria_components.CheckboxGroupProps, "children" | "className" | "style"> & {
+    children?: RenderPropsChildren<CheckboxGroupRenderProps>;
+    classNames?: CheckboxClassNames;
+    label?: string;
+    orientation?: react_aria.Orientation;
+} & Pick<{
+    children?: RenderPropsChildren<CheckboxRenderProps>;
+    label?: string;
+    classNames?: CheckboxClassNames;
+    alignInput?: CheckboxAlignment;
+}, "alignInput"> & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+
+declare function Chip(props: ChipProps): react_jsx_runtime.JSX.Element;
+declare const ChipContext: react.Context<ContextValue<ChipItemProps, HTMLDivElement>>;
+/**
+ * Must be used in conjunction with ChipList & ChipGroup and
+ * cannot be used outside of ChipList, else will throw error
+ *
+ * Color & Size props can be passed in from ChipGroup and overriden
+ * on each instance of this components
+ *
+ * Order of precedence (from lowest to highest):
+ * Design System Defaults of Chip
+ * Global Defaults of ChipGroup
+ * Instance of ChipGroup
+ * Global Defaults of ChipItem
+ * Instance of ChipItem
+ */
+declare const ChipItem: (props: Omit<react_aria_components.TagProps, "children" | "className" | "style"> & BaseChipProps & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+/**
+ * Must be used in conjunction with ChipItem & ChipGroup and
+ * cannot be used outside of ChipGroup, else will throw error
+ */
+declare function ChipList<T extends object>({ classNames: classNamesProp, ...rest }: ChipListProps<T>): react_jsx_runtime.JSX.Element;
+declare const ChipGroupContext: react.Context<ContextValue<ChipGroupProps, HTMLDivElement>>;
+/**
+ * Color & Size props are passed down to ChipItem but can be overridden
+ * on each component if desired
+ */
+declare const ChipGroup: (props: Omit<react_aria_components.TagGroupProps, "className" | "style"> & Omit<BaseChipProps, "children"> & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+
+type MergeProviderProps<A = any, B = any, C = any, D = any, E = any, F = any, G = any, H = any, I = any, J = any, K = any> = PropsWithChildren<{
+    values: ProviderValues<A, B, C, D, E, F, G, H, I, J, K>;
+}>;
+
+/**
+ * Merges provided contexts with parent contexts, if available and of the same structure
+ * If parent context doesn't exist or differs in structure (slotted vs non-slotted) from
+ * the context being provided, the provided context will override the parent context
+ *
+ * This is typically used in conjunction with React Aria Component's contexts, where a
+ * RAC may provide a slotted context (ex: ButtonContext, with a slot of "remove") where
+ * that slot has a number of attributes and event listeners, but we want to merge in our
+ * own to supplement things for stylistic or additional functionality purposes
+ *
+ * See tests for examples
+ */
+declare function MergeProvider<A, B, C, D, E, F, G, H, I, J, K>({ values, children, }: MergeProviderProps<A, B, C, D, E, F, G, H, I, J, K>): react_jsx_runtime.JSX.Element;
+
+/**
+ * Replace the default collection renderer to allow for injection of
+ * context props for multiple composed components. Also enables use of
+ * Section as wrapper of list items at the top level as a styleable
+ * element within the RAC container
+ */
+declare function createCollectionRenderer<C extends {
+    readonly collection: Collection<Node<unknown>>;
+}, V extends MergeProviderProps['values']>(context: Context<C>, values: V): CollectionRenderer;
+
+declare const ComboBoxContext: react.Context<ContextValue<ComboBoxProps<object>, HTMLDivElement>>;
+declare const ComboBox: <T extends object>(props: Omit<react_aria_components.ComboBoxProps<T>, "className" | "style"> & {
+    classNames?: ComboBoxClassNames;
+    mapping?: Partial<ComboBoxMapping>;
+    size?: ComboBoxSizes;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+
+declare const DialogContext: react.Context<ContextValue<DialogProps, HTMLDivElement>>;
+declare const Dialog: (props: Omit<react_aria_components.ModalOverlayProps, "children" | "className" | "style"> & Pick<react_aria_components.DialogProps, "role"> & {
+    children?: RenderPropsChildren<DialogRenderProps>;
+    classNames?: Partial<{
+        portal: string;
+        container: string;
+        modal: string;
+        dialog: string;
+        header: string;
+        content: string;
+        footer: string;
+    }> | undefined;
+    mapping?: Partial<DialogMapping>;
+    parentRef?: react.RefObject<HTMLElement>;
+    size?: DialogSizes;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+
+declare function Drawer(props: DrawerProps): react_jsx_runtime.JSX.Element;
+declare function DrawerTabList<T extends object>(props: DrawerTabListProps<T>): react_jsx_runtime.JSX.Element;
+declare function DrawerTab(props: DrawerTabProps): react_jsx_runtime.JSX.Element;
+declare const DrawerDialog: (props: _react_types_shared.AriaLabelingProps & {
+    classNames?: DrawerClassNames;
+} & {
+    mapping?: DrawerMapping;
+} & {
+    children?: react.ReactNode | undefined;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+
+type ElementProps<A = any, B = any, C = any, D = any, E = any, F = any, G = any, H = any, I = any, J = any, K = any> = /**
+ * Initially tried to make these props generic and constrain props to element
+ * passed into generic, but ran into major performance issues with enormous
+ * type unions of all possible HTML elements props. It breaks all of TS
+ */ JSX.IntrinsicElements[keyof ReactHTML] & SlotProps & {
+    /**
+     * The HTML element to be rendered
+     */
+    as?: keyof ReactHTML;
+    /**
+     * Values passed to Provider, overrides parent contexts
+     */
+    values?: ProviderValues<A, B, C, D, E, F, G, H, I, J, K>;
+    /**
+     * Values passed to MergeProvider, merges with parent contexts
+     */
+    mergeValues?: ProviderValues<A, B, C, D, E, F, G, H, I, J, K>;
+};
+
+declare const ElementContext: react.Context<ContextValue<ElementProps<any, any, any, any, any, any, any, any, any, any, any>, HTMLElement>>;
+/**
+ * This generic component serves as any easy way for more complex components
+ * to establish stylable content areas within their layout with optional
+ * targetted contexts for any subcomponents
+ *
+ * See Dialog & Drawer as examples
+ */
+declare const Element$1: <A, B, C, D, E, F, G, H, I, J, K>(props: ElementProps<A, B, C, D, E, F, G, H, I, J, K> & react.RefAttributes<HTMLElement>) => react.ReactElement | null;
+
+declare const GroupContext: react.Context<ContextValue<GroupProps<any, Element>, HTMLDivElement>>;
+/**
+ * This generic component allows for collective prop distribution to a collection of components of the same type
+ *
+ * @example A list of <Button />s and you want to control their size instead of passing the same props to each
+ */
+declare const Group: <T, E extends Element>(props: BaseGroupProps<T, E> & react_aria_components.SlotProps & react.RefAttributes<HTMLDivElement>) => ReactElement | null;
+
+declare const IconContext: react.Context<ContextValue<IconProps, HTMLDivElement>>;
+declare const Icon: (props: Pick<react.CSSProperties, "fill" | "color" | "stroke"> & {
+    classNames?: Partial<{
+        container: string;
+        icon: string;
+    }> | undefined;
+    size?: IconSizes;
+} & react_aria_components.SlotProps & {
+    children?: react.ReactNode | undefined;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+
+declare const InputContext: react.Context<ContextValue<InputProps, HTMLInputElement>>;
+/**
+ * Only intended for generic text-like inputs, see types in props for list
+ * Other more specific inputs should be handled by other components
+ */
+declare const Input: (props: Omit<InputProps$1, "children" | "className" | "style" | "size" | "type"> & BaseInputProps & react.RefAttributes<HTMLInputElement>) => react.ReactElement | null;
+
+declare const MenuContext: react.Context<ContextValue<MenuProps, HTMLElement>>;
+/**
+ * Menu component that supports display and selection of menu items via a trigger (right-click or click)
+ * Customization of React Aria's Menu and Menu Item components https://react-spectrum.adobe.com/react-aria/Menu.html
+ */
+declare const Menu: (props: Omit<react_aria_components.PopoverProps, "className" | "style"> & {
+    classNames?: MenuClassNames;
+    mapping?: Partial<MenuMapping>;
+    size?: MenuSizes;
+} & react.RefAttributes<HTMLElement>) => react.ReactElement | null;
+declare const MenuListContext: react.Context<ContextValue<MenuListProps<unknown>, HTMLDivElement>>;
+declare const MenuList: <T extends object>(props: Omit<react_aria_components.MenuProps<T>, "className" | "style"> & {
+    classNames?: MenuClassNames;
+    mapping?: Partial<MenuMapping>;
+    size?: MenuSizes;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+declare const MenuItemContext: react.Context<ContextValue<MenuItemProps<unknown>, HTMLDivElement>>;
+declare const MenuItem: <T extends object>(props: Omit<react_aria_components.MenuItemProps<T>, "className" | "style"> & {
+    classNames?: MenuClassNames;
+    mapping?: Partial<MenuMapping>;
+    size?: MenuSizes;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+
+declare const NumberFieldContext: react.Context<ContextValue<NumberFieldProps, HTMLDivElement>>;
+declare const NumberField: (props: {
+    id?: string | undefined;
+    children?: react.ReactNode | ((values: NumberFieldRenderProps & {
+        defaultChildren: react.ReactNode | undefined;
+    }) => react.ReactNode);
+    value?: number | undefined;
+    slot?: (string | null) | undefined;
+    isDisabled?: boolean | undefined;
+    autoFocus?: boolean | undefined;
+    onFocus?: ((e: react.FocusEvent<Element, Element>) => void) | undefined;
+    onBlur?: ((e: react.FocusEvent<Element, Element>) => void) | undefined;
+    onFocusChange?: ((isFocused: boolean) => void) | undefined;
+    onKeyDown?: ((e: _react_types_shared.KeyboardEvent) => void) | undefined;
+    onKeyUp?: ((e: _react_types_shared.KeyboardEvent) => void) | undefined;
+    'aria-label'?: string | undefined;
+    'aria-labelledby'?: string | undefined;
+    'aria-describedby'?: string | undefined;
+    'aria-details'?: string | undefined;
+    name?: string | undefined;
+    onChange?: ((value: number) => void) | undefined;
+    isReadOnly?: boolean | undefined;
+    isInvalid?: boolean | undefined;
+    isRequired?: boolean | undefined;
+    validationBehavior?: ("native" | "aria") | undefined;
+    validate?: ((value: number) => _react_types_shared.ValidationError | true | null | undefined) | undefined;
+    defaultValue?: number | undefined;
+    step?: number | undefined;
+    onCopy?: react.ClipboardEventHandler<HTMLInputElement> | undefined;
+    onCut?: react.ClipboardEventHandler<HTMLInputElement> | undefined;
+    onPaste?: react.ClipboardEventHandler<HTMLInputElement> | undefined;
+    onCompositionEnd?: react.CompositionEventHandler<HTMLInputElement> | undefined;
+    onCompositionStart?: react.CompositionEventHandler<HTMLInputElement> | undefined;
+    onCompositionUpdate?: react.CompositionEventHandler<HTMLInputElement> | undefined;
+    onBeforeInput?: react.FormEventHandler<HTMLInputElement> | undefined;
+    onInput?: react.FormEventHandler<HTMLInputElement> | undefined;
+    onSelect?: react.ReactEventHandler<HTMLInputElement> | undefined;
+    decrementAriaLabel?: string | undefined;
+    incrementAriaLabel?: string | undefined;
+    isWheelDisabled?: boolean | undefined;
+    formatOptions?: Intl.NumberFormatOptions | undefined;
+    minValue?: number | undefined;
+    maxValue?: number | undefined;
+} & {
+    classNames?: NumberFieldClassNames;
+    mapping?: Partial<NumberFieldMapping>;
+    size?: NumberFieldSizes;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+
+declare const OptionsContext: react.Context<ContextValue<OptionsProps, HTMLElement>>;
+declare const Options: (props: Omit<react_aria_components.PopoverProps, "className" | "style"> & {
+    classNames?: OptionsClassNames;
+    mapping?: Partial<OptionsMapping>;
+    size?: OptionsSizes;
+} & react.RefAttributes<HTMLElement>) => react.ReactElement | null;
+declare const OptionsListContext: react.Context<ContextValue<OptionsListProps<object>, HTMLDivElement>>;
+declare const OptionsList: <T extends object>(props: Omit<react_aria_components.ListBoxProps<T>, "className" | "style" | "orientation" | "dragAndDropHooks"> & {
+    classNames?: OptionsClassNames;
+    mapping?: Partial<OptionsMapping>;
+    size?: OptionsSizes;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+declare const OptionsItemContext: react.Context<ContextValue<OptionsItemProps<object>, HTMLDivElement>>;
+declare const OptionsItem: <T extends object>(props: Omit<react_aria_components.ListBoxItemProps<T>, "className" | "style"> & {
+    classNames?: OptionsClassNames;
+    mapping?: Partial<OptionsMapping>;
+    size?: OptionsSizes;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+
+declare const PickerContext: react.Context<ContextValue<PickerProps<unknown>, HTMLDivElement>>;
+declare const PickerItemContext: react.Context<ContextValue<PickerItemProps<unknown>, HTMLDivElement>>;
+/**
+ * Generic stylable picker that supports the functionality (sans drag and drop) of
+ * React Aria's ListBox: https://react-spectrum.adobe.com/react-aria/ListBox.html
+ *
+ * NOTE: The picker items does not support sections or separators
+ */
+declare const Picker: <T extends object>(props: Omit<react_aria_components.ListBoxProps<T>, "className" | "style" | "dragAndDropHooks"> & {
+    classNames?: PickerClassNames;
+} & {
+    columns?: number;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+declare const PickerItem: <T extends object>(props: Omit<react_aria_components.ListBoxItemProps<T>, "className" | "style"> & {
+    classNames?: PickerClassNames;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+
+declare const PopoverContext: react.Context<ContextValue<PopoverProps, HTMLElement>>;
+declare const Popover: (props: Omit<react_aria_components.PopoverProps, "children" | "className" | "style"> & {
+    children?: RenderPropsChildren<PopoverRenderProps>;
+    classNames?: PopoverClassNames;
+    mapping?: Partial<PopoverMapping>;
+} & react.RefAttributes<HTMLElement>) => react.ReactElement | null;
+
+declare const QueryBuilderContext: react.Context<QueryBuilderContextValue>;
+
+declare function QueryBuilder({ classNames: classNamesProp, consistentColumns, controlElements: controlElementsProp, disabled, icons, mapping: mappingProp, size, valueEditors: valueEditorsProp, ...rest }: QueryBuilderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * This is required because the C2DS Button supports an onPress event but
+ * QueryBuilder provides a callback that expects a MouseEvent and will error
+ * out if preventDefault is not available as a method.
+ * @param event
+ */
+declare const pressToMouseEvent: (event: PressEvent) => MouseEvent;
+
+declare const RadioContext: react.Context<ContextValue<RadioContextProps, HTMLLabelElement>>;
+declare const Radio: (props: Omit<react_aria_components.RadioProps, "children" | "className" | "style"> & {
+    children?: RenderPropsChildren<RadioRenderProps>;
+    label?: string;
+    classNames?: RadioClassNames;
+    alignInput?: RadioAlignment;
+} & react.RefAttributes<HTMLLabelElement>) => react.ReactElement | null;
+declare const RadioGroupContext: react.Context<ContextValue<RadioGroupProps, HTMLDivElement>>;
+declare const RadioGroup: (props: Omit<react_aria_components.RadioGroupProps, "className" | "style"> & Pick<{
+    children?: RenderPropsChildren<RadioRenderProps>;
+    label?: string;
+    classNames?: RadioClassNames;
+    alignInput?: RadioAlignment;
+}, "classNames" | "label" | "alignInput"> & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+
+declare const SearchFieldContext: react.Context<ContextValue<SearchFieldProps, HTMLDivElement>>;
+declare const SearchField: (props: Omit<react_aria_components.SearchFieldProps, "className" | "style" | "type"> & {
+    classNames?: SearchFieldClassNames;
+    mapping?: Partial<SearchFieldMapping>;
+    size?: InputSize;
+    variant?: SearchFieldVariants;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+
+declare const SelectContext: react.Context<ContextValue<SelectProps<object>, HTMLDivElement>>;
+declare const Select: <T extends object>(props: Omit<react_aria_components.SelectProps<T>, "className" | "style"> & {
+    classNames?: SelectClassNames;
+    mapping?: Partial<SelectMapping>;
+    size?: SelectSizes;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+
+declare const SwitchContext: react.Context<ContextValue<SwitchProps, HTMLLabelElement>>;
+declare const Switch: (props: Omit<react_aria_components.SwitchProps, "children" | "className" | "style"> & BaseSwitchProps & react.RefAttributes<HTMLLabelElement>) => react.ReactElement | null;
+
+declare const TabsContext: react.Context<ContextValue<TabsProps, HTMLDivElement>>;
+/**
+ * A required wrapper for other Tabs components, which manages
+ * and provides the state context. Other Tabs components will
+ * throw an error if not wrapped with this component
+ *
+ * NOTE: TabList & TabPanels do not have to be direct children
+ * of this component. Additional layout can be introduced around
+ * this components children
+ */
+declare const Tabs: (props: Omit<react_aria_components.TabsProps, "children" | "className" | "style"> & {
+    classNames?: TabsClassNames;
+} & {
+    children?: react.ReactNode | undefined;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+declare const TabListContext: react.Context<ContextValue<TabListProps<unknown>, HTMLDivElement>>;
+/**
+ * Parent of Tab
+ */
+declare const TabList: <T extends object>(props: Omit<react_aria_components.TabListProps<T>, "className" | "style"> & {
+    align?: TabListAlignment;
+    anchor?: TabListAnchor;
+    orientation?: react_aria.Orientation;
+    size?: TabListSizes;
+    variant?: TabListVariants;
+} & {
+    classNames?: TabsClassNames;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+declare const TabContext: react.Context<ContextValue<Omit<Omit<react_aria_components.TabProps, "className" | "style"> & {
+    id: string;
+} & react_aria.PressEvents & {
+    classNames?: TabsClassNames;
+} & SlotProps, "id">, HTMLDivElement>>;
+/**
+ * Must be a direct child of TabList
+ */
+declare const Tab: (props: Omit<react_aria_components.TabProps, "className" | "style"> & {
+    id: string;
+} & react_aria.PressEvents & {
+    classNames?: TabsClassNames;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+declare const TabPanelsContext: react.Context<ContextValue<TabPanelsProps, HTMLDivElement>>;
+/**
+ * Parent of TabPanel, but only required if using shouldForceMount=true
+ */
+declare const TabPanels: (props: {
+    shouldForceMount?: boolean;
+} & {
+    children?: react.ReactNode | undefined;
+} & {
+    classNames?: TabsClassNames;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+declare const TabPanelContext: react.Context<ContextValue<Omit<TabPanelProps, "id">, HTMLDivElement>>;
+/**
+ * Must be direct child of TabPanels if TabPanel implements shouldForceMount=true
+ *
+ * Othewise can be used anywhere inside of Tabs. TabPanels may be desirable to use
+ * if theme implements any styles that adjust layout
+ */
+declare const TabPanel: (props: Omit<react_aria_components.TabPanelProps, "className" | "style"> & {
+    id: string;
+} & {
+    classNames?: TabsClassNames;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+
+declare const TextAreaContext: react.Context<ContextValue<TextAreaProps, HTMLTextAreaElement>>;
+/**
+ * We implement a textarea as a content editable span to provide
+ * improved UX, where the input area automatically grows with input
+ * content length. This can be overriden by applying max-height
+ * and overflow CSS, if desired.
+ *
+ * This also has the side effect of changing the target element in
+ * the ref and event handlers. The normal `event.target.value` is not
+ * available, and must be substituted with `event.currentTarget.textContent`
+ */
+declare const TextArea: (props: Omit<TextAreaProps$1, "children" | "className" | "style" | "onChange" | "cols" | "rows"> & BaseTextAreaProps & react.RefAttributes<HTMLTextAreaElement>) => react.ReactElement | null;
+
+declare const TextFieldContext: react.Context<ContextValue<TextFieldProps, HTMLDivElement>>;
+declare const TextField: (props: {
+    id?: string | undefined;
+    children?: react.ReactNode | ((values: TextFieldRenderProps & {
+        defaultChildren: react.ReactNode | undefined;
+    }) => react.ReactNode);
+    value?: string | undefined;
+    type?: ("text" | "search" | "url" | "tel" | "email" | "password" | (string & {})) | undefined;
+    slot?: (string | null) | undefined;
+    isDisabled?: boolean | undefined;
+    autoFocus?: boolean | undefined;
+    onFocus?: ((e: react.FocusEvent<Element, Element>) => void) | undefined;
+    onBlur?: ((e: react.FocusEvent<Element, Element>) => void) | undefined;
+    onFocusChange?: ((isFocused: boolean) => void) | undefined;
+    onKeyDown?: ((e: _react_types_shared.KeyboardEvent) => void) | undefined;
+    onKeyUp?: ((e: _react_types_shared.KeyboardEvent) => void) | undefined;
+    'aria-haspopup'?: (boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog") | undefined;
+    excludeFromTabOrder?: boolean | undefined;
+    'aria-label'?: string | undefined;
+    'aria-labelledby'?: string | undefined;
+    'aria-describedby'?: string | undefined;
+    'aria-details'?: string | undefined;
+    name?: string | undefined;
+    onChange?: ((value: string) => void) | undefined;
+    isReadOnly?: boolean | undefined;
+    isInvalid?: boolean | undefined;
+    isRequired?: boolean | undefined;
+    validationBehavior?: ("native" | "aria") | undefined;
+    validate?: ((value: string) => _react_types_shared.ValidationError | true | null | undefined) | undefined;
+    'aria-errormessage'?: string | undefined;
+    defaultValue?: string | undefined;
+    autoComplete?: string | undefined;
+    maxLength?: number | undefined;
+    minLength?: number | undefined;
+    pattern?: string | undefined;
+    inputMode?: ("none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search") | undefined;
+    'aria-activedescendant'?: string | undefined;
+    'aria-autocomplete'?: ("none" | "inline" | "list" | "both") | undefined;
+    onCopy?: react.ClipboardEventHandler<HTMLInputElement> | undefined;
+    onCut?: react.ClipboardEventHandler<HTMLInputElement> | undefined;
+    onPaste?: react.ClipboardEventHandler<HTMLInputElement> | undefined;
+    onCompositionEnd?: react.CompositionEventHandler<HTMLInputElement> | undefined;
+    onCompositionStart?: react.CompositionEventHandler<HTMLInputElement> | undefined;
+    onCompositionUpdate?: react.CompositionEventHandler<HTMLInputElement> | undefined;
+    onBeforeInput?: react.FormEventHandler<HTMLInputElement> | undefined;
+    onInput?: react.FormEventHandler<HTMLInputElement> | undefined;
+    onSelect?: react.ReactEventHandler<HTMLInputElement> | undefined;
+} & {
+    classNames?: TextFieldClassNames;
+    mapping?: Partial<TextFieldMapping>;
+    size?: TextFieldSizes;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+
+declare const TooltipContext: react.Context<ContextValue<TooltipProps, HTMLDivElement>>;
+declare const Tooltip: (props: Omit<react_aria_components.TooltipProps, "className" | "style" | "UNSTABLE_portalContainer"> & {
+    classNames?: TooltipClassNames;
+    mapping?: Partial<TooltipMapping>;
+} & {
+    children?: RenderPropsChildren<TooltipRenderProps>;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+declare const TooltipTargetContext: react.Context<ContextValue<TooltipTargetProps, HTMLDivElement>>;
+/**
+ * This target component is only needed if attempting to add a Tooltip
+ * to a non-focusable element/component
+ */
+declare const TooltipTarget: (props: {
+    classNames?: TooltipClassNames;
+    mapping?: Partial<TooltipMapping>;
+} & {
+    focusable?: boolean;
+    relative?: "parent" | "self";
+} & {
+    children?: react.ReactNode | undefined;
+} & react.RefAttributes<HTMLDivElement>) => react.ReactElement | null;
+
+declare const TreeStateContext: react.Context<TreeStateContextValue<any>>;
+declare function Tree<T>(props: TreeProps<T>): react_jsx_runtime.JSX.Element;
+declare function TreeGroup<T>({ id, children, nodes, types, ...rest }: TreeGroupProps<T>): react_jsx_runtime.JSX.Element;
+declare function TreeItem<T>({ children: childrenProp, index, mapping: mappingProp, node, isFirstChild, isLastChild, ...rest }: TreeItemProps<T>): react_jsx_runtime.JSX.Element;
+
+/**
+ * Copied from RAC, unexported hook: https://github.com/adobe/react-spectrum/blob/main/packages/react-aria-components/src/Collection.tsx#L148
+ *
+ * Hook serves as the basis of the root and branch renderers for Collections: https://github.com/adobe/react-spectrum/blob/main/packages/react-aria-components/src/Collection.tsx#L139
+ */
+declare function useCollectionRender(collection: Collection<Node<unknown>>, parent: Node<unknown> | null, renderDropIndicator?: (target: ItemDropTarget) => ReactNode): ReactNode;
+
+/**
+ * Reimplementation of React Aria's useContextProps, to utilize our own
+ * mergeProps which handles renderProps and classNames
+ */
+declare function useContextProps<T, U extends SlotProps, E extends Element>(props: T & SlotProps, ref: ForwardedRef<E>, context: Context<ContextValue<U, E>>): [T, RefObject<E | null>];
+
+type DefaultsOf<T extends Record<string, object>> = {
+    [K in keyof T]?: OmitProtectedProps<T[K]>;
+};
+type DefaultsContext = DefaultsOf<{
+    Button: ButtonProps;
+    Checkbox: CheckboxProps;
+    CheckboxGroup: CheckboxGroupProps;
+    Chip: ChipProps;
+    ChipGroup: ChipGroupProps;
+    ComboBox: ComboBoxProps<object>;
+    Dialog: DialogProps;
+    Drawer: DrawerProps;
+    DrawerTab: DrawerTabProps;
+    DrawerTabList: DrawerTabListProps<unknown>;
+    Icon: IconProps;
+    Input: InputProps;
+    LinkButton: LinkButtonProps;
+    Menu: MenuProps;
+    MenuList: MenuListProps<unknown>;
+    MenuItem: MenuItemProps<unknown>;
+    NumberField: NumberFieldProps;
+    Options: OptionsProps;
+    OptionsList: OptionsListProps<object>;
+    OptionsItem: OptionsItemProps<object>;
+    Picker: PickerProps<unknown>;
+    Popover: PopoverProps;
+    Radio: RadioProps;
+    RadioGroup: RadioGroupProps;
+    SearchField: SearchFieldProps;
+    Select: SelectProps<object>;
+    Switch: SwitchProps;
+    Tab: TabProps;
+    TabList: TabListProps<unknown>;
+    TabPanel: TabPanelProps;
+    TabPanels: TabPanelsProps;
+    Tabs: TabsProps;
+    TextArea: TextAreaProps;
+    TextField: TextFieldProps;
+    ToggleButton: ToggleButtonProps;
+    Tooltip: TooltipProps;
+    TooltipTarget: TooltipTargetProps;
+    Tree: TreeProps<unknown>;
+}>;
+type DefaultsProviderProps = PropsWithChildren<{
+    defaults: DefaultsContext;
+}>;
+
+/**
+ * Access globally established component prop defaults
+ */
+declare function useDefaults(): {
+    Button?: OmitProtectedProps<ButtonProps> | undefined;
+    Checkbox?: OmitProtectedProps<CheckboxProps> | undefined;
+    CheckboxGroup?: OmitProtectedProps<CheckboxGroupProps> | undefined;
+    Chip?: OmitProtectedProps<ChipProps> | undefined;
+    ChipGroup?: OmitProtectedProps<ChipGroupProps> | undefined;
+    ComboBox?: OmitProtectedProps<ComboBoxProps<object>> | undefined;
+    Dialog?: OmitProtectedProps<DialogProps> | undefined;
+    Drawer?: OmitProtectedProps<DrawerProps> | undefined;
+    DrawerTab?: OmitProtectedProps<DrawerTabProps> | undefined;
+    DrawerTabList?: OmitProtectedProps<DrawerTabListProps<unknown>> | undefined;
+    Icon?: OmitProtectedProps<IconProps> | undefined;
+    Input?: OmitProtectedProps<InputProps> | undefined;
+    LinkButton?: OmitProtectedProps<LinkButtonProps> | undefined;
+    Menu?: OmitProtectedProps<MenuProps> | undefined;
+    MenuList?: OmitProtectedProps<MenuListProps<unknown>> | undefined;
+    MenuItem?: OmitProtectedProps<MenuItemProps<unknown>> | undefined;
+    NumberField?: OmitProtectedProps<NumberFieldProps> | undefined;
+    Options?: OmitProtectedProps<OptionsProps> | undefined;
+    OptionsList?: OmitProtectedProps<OptionsListProps<object>> | undefined;
+    OptionsItem?: OmitProtectedProps<OptionsItemProps<object>> | undefined;
+    Picker?: OmitProtectedProps<PickerProps<unknown>> | undefined;
+    Popover?: OmitProtectedProps<PopoverProps> | undefined;
+    Radio?: OmitProtectedProps<RadioProps> | undefined;
+    RadioGroup?: OmitProtectedProps<RadioGroupProps> | undefined;
+    SearchField?: OmitProtectedProps<SearchFieldProps> | undefined;
+    Select?: OmitProtectedProps<SelectProps<object>> | undefined;
+    Switch?: OmitProtectedProps<SwitchProps> | undefined;
+    Tab?: OmitProtectedProps<TabProps> | undefined;
+    TabList?: OmitProtectedProps<TabListProps<unknown>> | undefined;
+    TabPanel?: OmitProtectedProps<TabPanelProps> | undefined;
+    TabPanels?: OmitProtectedProps<TabPanelsProps> | undefined;
+    Tabs?: OmitProtectedProps<TabsProps> | undefined;
+    TextArea?: OmitProtectedProps<TextAreaProps> | undefined;
+    TextField?: OmitProtectedProps<TextFieldProps> | undefined;
+    ToggleButton?: OmitProtectedProps<ToggleButtonProps> | undefined;
+    Tooltip?: OmitProtectedProps<TooltipProps> | undefined;
+    TooltipTarget?: OmitProtectedProps<TooltipTargetProps> | undefined;
+    Tree?: OmitProtectedProps<TreeProps<unknown>> | undefined;
+};
+/**
+ * Select default props from context and merge with provided props
+ * with provided props taking precedence
+ */
+declare function useDefaultProps<K extends keyof DefaultsContext, P extends DefaultsContext[K]>(props: P, key: K): P;
+/**
+ * Set default props for any component, to be merged in with props at point
+ * of implementation. Global defaults take lower priority than props from
+ * composition context or props attached to instance
+ *
+ * Nested instances of this provider will shallow merge defaults from parent
+ * context, with the defaults prop taking precedence
+ */
+declare function DefaultsProvider({ children, defaults: defaultsProp, }: DefaultsProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * The default behavior of usePress is to stop all propagation of press events
+ *
+ * To allow the more typical behavior of event propagation by default, this hook
+ * continues propagation of press events. This allows for nested press event
+ * listeners to not block press event listeners higher in the heirarchy
+ */
+declare function usePropagatingPress(props: PressHookProps): react_aria.PressResult;
+
+/**
+ * Detects whether a slot has been utilized
+ *
+ * Example:
+ * Parent component implements RAC Provider, with a slotted context
+ * Child component implements slot prop matching provided slot in context
+ * Parent is able to see that the slot has been fulfilled
+ *
+ * Copied from RAC: https://github.com/adobe/react-spectrum/blob/main/packages/react-aria-components/src/utils.tsx#L213
+ * Due to not being exported, but quite handy
+ */
+declare function useSlot(): [RefCallback<Element>, boolean];
+
+type ThemeContext = {
+    /**
+     * Intended as a way to pass classNames down to nested themes or global portals
+     */
+    className?: string;
+    /**
+     * Intended as a way to pass inline CSS variables down to nested themes or global portals
+     */
+    style?: CSSProperties;
+    /**
+     * Component specific classNames theme entrypoints
+     */
+    Button?: ButtonClassNames;
+    Checkbox?: CheckboxClassNames;
+    Chip?: ChipClassNames;
+    ComboBox?: ComboBoxClassNames;
+    Dialog?: DialogClassNames;
+    Drawer?: DrawerClassNames;
+    Group?: GroupClassNames;
+    Icon?: IconClassNames;
+    Input?: InputClassNames;
+    Menu?: MenuClassNames;
+    NumberField?: NumberFieldClassNames;
+    Options?: OptionsClassNames;
+    Picker?: PickerClassNames;
+    Popover?: PopoverClassNames;
+    QueryBuilder?: QueryBuilderClassNames;
+    Radio?: RadioClassNames;
+    SearchField?: SearchFieldClassNames;
+    Select?: SelectClassNames;
+    Switch?: SwitchClassNames;
+    Tabs?: TabsClassNames;
+    TextArea?: TextAreaClassNames;
+    TextField?: TextFieldClassNames;
+    Tooltip?: TooltipClassNames;
+    Tree?: TreeClassNames;
+};
+type ThemeVars = {
+    colors?: {
+        generic?: string;
+        semantic?: string;
+    };
+    elevation?: string;
+    focus?: string;
+    radius?: string;
+    sizes?: string;
+    space?: string;
+    typography?: string;
+    zIndex?: string;
+};
+type ThemeProviderProps = PropsWithChildren<{
+    className?: string;
+    /**
+     * Set to true to skip defaults and inherit classNames, styles, theme & vars from parent
+     * All other props will be merged on top of inherited theme
+     */
+    inherit?: boolean;
+    /**
+     * Use to set runtime CSS variables, not intended for other styles. Will be passed to
+     * nested themes and global portals
+     */
+    style?: CSSProperties;
+    theme?: ThemeContext;
+    vars?: ThemeVars;
+}>;
+
+type ContinuableEvent = {
+    continuePropagation: () => void;
+};
+/**
+ * The default behavior of events within React Aria is to stop progagation
+ *
+ * To reenable propagation, continuePropagation must be called
+ */
+declare function continuePropagation(event: ContinuableEvent): void;
+
+type Props<T extends object> = AsType<T> | null | undefined;
+/**
+ * Deep merges classNames objects by concatenating class values
+ *
+ * @example
+ * mergeClassNames({ foo: 'foo' }, { foo: 'FOO', bar: 'bar' })
+ * // returns { foo: 'foo FOO', bar: 'bar' }
+ */
+declare function mergeClassNames<T extends ClassNames>(...classNamesToMerge: (T | null | undefined)[]): T | undefined;
+/**
+ * Extends the base margeProps functionality to also merge styles and handle class/style render props
+ */
+declare function mergeProps<T extends object>(...propsToMerge: Props<T>[]): T;
+/**
+ * A helper for not having to reimplement the type check for a renderProp value being a function or not everywhere
+ */
+declare function callRenderProps<T extends object, R>(value: R | ((renderProps: T) => R), values: T): R;
+/**
+ * A helper function to pair with React Aria's render props. Typically
+ * implemented with children, className and styles
+ *
+ * Allows for the injection of additional renderProps that a component
+ * from React Aria may not already provide
+ *
+ * If the value isn't a renderProp function, then it is passed through unchanged
+ */
+declare function wrapRenderProps<T extends object, U extends object, R>(value: R | ((renderProps: T & U) => R), inject?: U): R | ((renderProps: T) => R);
+
+/**
+ * Test for any safe number that could represent a pixel value
+ */
+declare const pixelValueAsNumberValidator: z.ZodNumber;
+/**
+ * Test for and capture numeric pixel values
+ * Will allow decimals and negative numbers
+ *
+ * Examples:
+ * 0 -> 0
+ * 1px -> 1
+ * 20.5px -> 20.5
+ */
+declare const pixelValueAsStringValidator: z.ZodPipeline<z.ZodPipeline<z.ZodUnion<[z.ZodLiteral<"0">, z.ZodEffects<z.ZodString, string, string>]>, z.ZodNumber>, z.ZodNumber>;
+/**
+ * Test for an integer in the range of 0-255 as a representation of an RGB color channel value
+ */
+declare const colorChannelAsNumberValidator: z.ZodNumber;
+/**
+ * Test for and convert CSS RGB color channel to numeric value (0-255)
+ */
+declare const colorChannelAsStringValidator: z.ZodPipeline<z.ZodPipeline<z.ZodString, z.ZodNumber>, z.ZodNumber>;
+/**
+ * DeckGL treats alpha channel the same as color channels (0-255)
+ */
+declare const alphaChannelAsNumberValidator: z.ZodNumber;
+/**
+ * Test for and convert CSS RGBA alpha channel to DeckGL numeric value
+ */
+declare const alphaChannelAsStringValidator: z.ZodEffects<z.ZodPipeline<z.ZodString, z.ZodNumber>, number, string>;
+/**
+ * Test for and convert CSS RGB(A) values to numeric RGBA tuple
+ * Will only allow for rgb with 3 valid numbers (0-255){3, intergers only}
+ * Will only allow for rgba with 4 valid numbers (0-255){3, intergers only} + (0-1){1, decimals allowed}
+ * Will allow for whitespace spread throughout
+ *
+ * Examples:
+ * rgb( 0, 0, 0 ) -> [0, 0, 0, 255]
+ * rgba(203,117,98,0.4) -> [203, 117, 98, 102]
+ */
+declare const rgbaAsStringValidator: z.ZodPipeline<z.ZodEffects<z.ZodUnion<[z.ZodEffects<z.ZodString, string, string>, z.ZodEffects<z.ZodString, string, string>]>, string[], string>, z.ZodTuple<[z.ZodPipeline<z.ZodPipeline<z.ZodString, z.ZodNumber>, z.ZodNumber>, z.ZodPipeline<z.ZodPipeline<z.ZodString, z.ZodNumber>, z.ZodNumber>, z.ZodPipeline<z.ZodPipeline<z.ZodString, z.ZodNumber>, z.ZodNumber>, z.ZodEffects<z.ZodPipeline<z.ZodString, z.ZodNumber>, number, string>], null>>;
+/**
+ * Test for numeric RGB(A) tuple
+ *
+ * Will return RGB as RGBA with 100% alpha channel
+ */
+declare const rgbaAsTupleValidator: z.ZodUnion<[z.ZodEffects<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, RGBA, [number, number, number]>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>;
+
+/**
+ * Computes CSS values into DeckGL compatible formats using the optionally provided contract
+ *
+ * This function allows for the reuse of CSS contract tokens within React context for non-CSS
+ * use cases. This ensures synchronized theming across the entire rendering stack
+ */
+declare function useTheme<T extends Contract>(contract?: T): ThemeContext & {
+    contract?: ReturnType<typeof computeContract<T>>;
+};
+declare function ThemeProvider({ children, className: classNameProp, inherit, style: styleProp, theme: themeProp, vars, }: ThemeProviderProps): react_jsx_runtime.JSX.Element;
+
+declare function useTree<T>({ allowsExpansion, allowsVisibility, nodes, selectionMode, onSelectionChange, onUpdate, }: UseTreeOptions<T>): UseTreeResult<T>;
+
+declare function useUpdateEffect(effect: () => void, deps: any): void;
+
+export { AriaFieldError, AriaFieldErrorContext, AriaGroup, AriaGroupContext, AriaHeader, AriaHeaderContext, AriaHeading, AriaHeadingContext, AriaKeyboard, AriaKeyboardContext, AriaLabel, AriaLabelContext, AriaSection, AriaSectionContext, AriaSelectValue, AriaSelectValueContext, AriaSeparator, AriaSeparatorContext, AriaText, AriaTextContext, AsType, Button, ButtonClassNames, ButtonColors, ButtonContext, ButtonMapping, ButtonProps, ButtonRenderProps, ButtonSizes, Checkbox, CheckboxAlignment, CheckboxClassNames, CheckboxContext, CheckboxGroup, CheckboxGroupContext, CheckboxGroupProps, CheckboxGroupRenderProps, CheckboxProps, CheckboxRenderProps, Chip, ChipClassNames, ChipContext, ChipGroup, ChipGroupContext, ChipGroupProps, ChipItem, ChipItemProps, ChipList, ChipListProps, ChipProps, ClassNames, ComboBox, ComboBoxClassNames, ComboBoxContext, ComboBoxMapping, ComboBoxProps, ComboBoxSizes, Contract, type DefaultsContext, DefaultsProvider, type DefaultsProviderProps, Dialog, DialogClassNames, DialogContext, DialogMapping, DialogProps, DialogRenderProps, DialogSizes, Drawer, DrawerClassNames, DrawerDialog, DrawerMapping, DrawerProps, DrawerTab, DrawerTabList, DrawerTabListProps, DrawerTabProps, Element$1 as Element, ElementContext, type ElementProps, Group, GroupClassNames, GroupContext, GroupProps, Icon, IconClassNames, IconContext, IconProps, IconSizes, Input, InputClassNames, InputContext, InputProps, LinkButton, LinkButtonContext, LinkButtonProps, Menu, MenuClassNames, MenuContext, MenuItem, MenuItemContext, MenuItemProps, MenuList, MenuListContext, MenuListProps, MenuMapping, MenuProps, MenuSizes, MergeProvider, type MergeProviderProps, NumberField, NumberFieldClassNames, NumberFieldContext, NumberFieldMapping, NumberFieldProps, NumberFieldSizes, OmitProtectedProps, Options, OptionsClassNames, OptionsContext, OptionsItem, OptionsItemContext, OptionsItemProps, OptionsList, OptionsListContext, OptionsListProps, OptionsMapping, OptionsProps, OptionsSizes, Picker, PickerClassNames, PickerContext, PickerItem, PickerItemContext, PickerItemProps, PickerProps, Popover, PopoverClassNames, PopoverContext, PopoverProps, ProviderValues, QueryBuilder, QueryBuilderClassNames, QueryBuilderContext, QueryBuilderContextValue, QueryBuilderProps, RGBA, Radio, RadioAlignment, RadioClassNames, RadioContext, RadioGroup, RadioGroupContext, RadioGroupProps, RadioProps, RenderPropsChildren, SearchField, SearchFieldClassNames, SearchFieldContext, SearchFieldMapping, SearchFieldProps, Select, SelectClassNames, SelectContext, SelectMapping, SelectProps, Switch, SwitchClassNames, SwitchContext, SwitchProps, Tab, TabContext, TabList, TabListAlignment, TabListAnchor, TabListContext, TabListProps, TabListVariants, TabPanel, TabPanelContext, TabPanelProps, TabPanels, TabPanelsContext, TabPanelsProps, TabProps, Tabs, TabsClassNames, TabsContext, TabsProps, TextArea, TextAreaClassNames, TextAreaContext, TextAreaProps, TextField, TextFieldClassNames, TextFieldContext, TextFieldMapping, TextFieldProps, TextFieldSizes, type ThemeContext, ThemeProvider, type ThemeVars, ToggleButton, ToggleButtonContext, ToggleButtonProps, Tooltip, TooltipClassNames, TooltipContext, TooltipMapping, TooltipProps, TooltipRenderProps, TooltipTarget, TooltipTargetContext, TooltipTargetProps, Tree, TreeClassNames, TreeGroup, TreeGroupProps, TreeItem, TreeItemProps, TreeProps, TreeStateContext, TreeStateContextValue, UseTreeOptions, UseTreeResult, alphaChannelAsNumberValidator, alphaChannelAsStringValidator, callRenderProps, colorChannelAsNumberValidator, colorChannelAsStringValidator, computeContract, continuePropagation, createCollectionRenderer, mergeClassNames, mergeProps, pixelValueAsNumberValidator, pixelValueAsStringValidator, pressToMouseEvent, rgbaAsStringValidator, rgbaAsTupleValidator, useCollectionRender, useContextProps, useDefaultProps, useDefaults, usePropagatingPress, useSlot, useTheme, useTree, useUpdateEffect, wrapRenderProps };