@atlaskit/react-select 2.1.0 → 2.2.1

package/dist/esm/emotion/components/option.js

@@ -0,0 +1,75 @@
+import _extends from "@babel/runtime/helpers/extends";
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+
+import { jsx } from '@emotion/react';
+import { getStyleProps } from '../../utils';
+export var optionCSS = function optionCSS(_ref) {
+  var isDisabled = _ref.isDisabled,
+    isFocused = _ref.isFocused,
+    isSelected = _ref.isSelected;
+  var color = "var(--ds-text, #172B4D)";
+  if (isDisabled) {
+    color = "var(--ds-text-disabled, #091E424F)";
+  } else if (isSelected) {
+    color = "var(--ds-text-selected, #0C66E4)";
+  }
+  var boxShadow;
+  var backgroundColor;
+  if (isDisabled) {
+    backgroundColor = undefined;
+  } else if (isSelected && isFocused) {
+    backgroundColor = "var(--ds-background-selected-hovered, #CCE0FF)";
+  } else if (isSelected) {
+    backgroundColor = "var(--ds-background-selected, #E9F2FF)";
+  } else if (isFocused) {
+    backgroundColor = "var(--ds-background-neutral-subtle-hovered, #091E420F)";
+  }
+  if (!isDisabled && (isFocused || isSelected)) {
+    boxShadow = "inset 2px 0px 0px ".concat("var(--ds-border-selected, #0C66E4)");
+  }
+  var cursor = isDisabled ? 'not-allowed' : 'default';
+  return {
+    label: 'option',
+    display: 'block',
+    // eslint-disable-next-line @atlaskit/design-system/use-tokens-typography
+    fontSize: 'inherit',
+    width: '100%',
+    userSelect: 'none',
+    WebkitTapHighlightColor: 'rgba(0, 0, 0, 0)',
+    padding: "var(--ds-space-075, 6px)".concat(" ", "var(--ds-space-150, 12px)"),
+    backgroundColor: backgroundColor,
+    color: color,
+    cursor: cursor,
+    boxShadow: boxShadow,
+    ':active': {
+      backgroundColor: !isDisabled ? isSelected ? "var(--ds-background-selected-pressed, #85B8FF)" : "var(--ds-background-neutral-subtle-pressed, #091E4224)" : undefined
+    },
+    '@media screen and (-ms-high-contrast: active)': {
+      borderLeft: !isDisabled && (isFocused || isSelected) ? '2px solid transparent' : ''
+    }
+  };
+};
+var Option = function Option(props) {
+  var children = props.children,
+    isDisabled = props.isDisabled,
+    isFocused = props.isFocused,
+    isSelected = props.isSelected,
+    innerRef = props.innerRef,
+    innerProps = props.innerProps;
+  return jsx("div", _extends({}, getStyleProps(props, 'option', {
+    option: true,
+    'option--is-disabled': isDisabled,
+    'option--is-focused': isFocused,
+    'option--is-selected': isSelected
+  }), {
+    ref: innerRef
+  }, innerProps, {
+    tabIndex: -1
+  }), children);
+};
+
+// eslint-disable-next-line @repo/internal/react/require-jsdoc
+export default Option;

package/dist/esm/emotion/components/placeholder.js

@@ -0,0 +1,27 @@
+import _extends from "@babel/runtime/helpers/extends";
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+
+import { jsx } from '@emotion/react';
+import { getStyleProps } from '../../utils';
+export var placeholderCSS = function placeholderCSS(_ref) {
+  var isDisabled = _ref.isDisabled;
+  return {
+    label: 'placeholder',
+    gridArea: '1 / 1 / 2 / 3',
+    margin: "0 ".concat("var(--ds-space-025, 2px)"),
+    color: isDisabled ? "var(--ds-text-disabled, #091E424F)" : "var(--ds-text-subtlest, #626F86)"
+  };
+};
+var Placeholder = function Placeholder(props) {
+  var children = props.children,
+    innerProps = props.innerProps;
+  return jsx("div", _extends({}, getStyleProps(props, 'placeholder', {
+    placeholder: true
+  }), innerProps), children);
+};
+
+// eslint-disable-next-line @repo/internal/react/require-jsdoc
+export default Placeholder;

package/dist/esm/emotion/components/single-value.js

@@ -0,0 +1,33 @@
+import _extends from "@babel/runtime/helpers/extends";
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+
+import { jsx } from '@emotion/react';
+import { getStyleProps } from '../../utils';
+export var css = function css(_ref) {
+  var isDisabled = _ref.isDisabled;
+  return {
+    label: 'singleValue',
+    gridArea: '1 / 1 / 2 / 3',
+    maxWidth: '100%',
+    overflow: 'hidden',
+    textOverflow: 'ellipsis',
+    whiteSpace: 'nowrap',
+    margin: "0 ".concat("var(--ds-space-025, 2px)"),
+    color: isDisabled ? "var(--ds-text-disabled, #091E424F)" : "var(--ds-text, #172B4D)"
+  };
+};
+var SingleValue = function SingleValue(props) {
+  var children = props.children,
+    isDisabled = props.isDisabled,
+    innerProps = props.innerProps;
+  return jsx("div", _extends({}, getStyleProps(props, 'singleValue', {
+    'single-value': true,
+    'single-value--is-disabled': isDisabled
+  }), innerProps), children);
+};
+
+// eslint-disable-next-line @repo/internal/react/require-jsdoc
+export default SingleValue;

package/dist/esm/select.js

@@ -71,7 +71,8 @@ export var defaultProps = {
   },
   styles: {},
   tabIndex: 0,
-  tabSelectsValue: true
+  tabSelectsValue: true,
+  UNSAFE_is_experimental_generic: false
 };
 function toCategorizedOption(props, option, selectValue, index) {
   var isDisabled = _isOptionDisabled(props, option, selectValue);
@@ -1260,14 +1261,14 @@ var Select = /*#__PURE__*/function (_Component) {
         'aria-errormessage': this.props['aria-errormessage'],
         'aria-expanded': menuIsOpen,
         // TODO: aria-haspopup is implied as listbox with role="combobox" and was deprecated for aria 1.2, we still might need to keep it for back compat
-        'aria-haspopup': 'listbox',
+        'aria-haspopup': this.props['UNSAFE_is_experimental_generic'] ? 'dialog' : 'listbox',
         'aria-describedby': this.props['aria-describedby'] || descriptionId,
         'aria-invalid': this.props['aria-invalid'] || isInvalid,
         'aria-label': this.props['aria-label'] || label,
         'aria-labelledby': this.props['aria-labelledby'] || labelId,
         'aria-required': required || isRequired,
         role: 'combobox',
-        'aria-activedescendant': this.state.focusedOptionId || this.state.focusedValueId || undefined
+        'aria-activedescendant': this.props['UNSAFE_is_experimental_generic'] ? undefined : this.state.focusedOptionId || this.state.focusedValueId || undefined
       }, menuIsOpen && {
         'aria-controls': this.getElementId('listbox')
       }), !isSearchable && {
@@ -1534,8 +1535,8 @@ var Select = /*#__PURE__*/function (_Component) {
           onClick: onSelect,
           onMouseMove: onHover,
           onMouseOver: onHover,
-          role: 'option',
-          'aria-selected': isSelected,
+          role: _this4.props['UNSAFE_is_experimental_generic'] ? 'listitem' : 'option',
+          'aria-selected': _this4.props['UNSAFE_is_experimental_generic'] ? undefined : isSelected,
           // We don't want aria-disabled if it's false. It's just noisy.
           'aria-disabled': !isDisabled && fg('design_system_select-a11y-improvement') ? undefined : isDisabled,
           'aria-describedby': fg('design_system_select-a11y-improvement') ? headingId : undefined
@@ -1660,8 +1661,8 @@ var Select = /*#__PURE__*/function (_Component) {
               scrollTargetRef(instance);
             },
             innerProps: _objectSpread(_objectSpread({
-              role: 'listbox',
-              'aria-multiselectable': (_this4.isVoiceOver || !commonProps.isMulti) && fg('design_system_select-a11y-improvement') ? undefined : commonProps.isMulti,
+              role: _this4.props['UNSAFE_is_experimental_generic'] ? 'dialog' : 'listbox',
+              'aria-multiselectable': (_this4.isVoiceOver || !commonProps.isMulti) && fg('design_system_select-a11y-improvement') || _this4.props['UNSAFE_is_experimental_generic'] ? undefined : commonProps.isMulti,
               id: _this4.getElementId('listbox')
             }, testId && {
               'data-testid': "".concat(testId, "-select--listbox")
@@ -1669,7 +1670,9 @@ var Select = /*#__PURE__*/function (_Component) {
             isLoading: isLoading,
             maxHeight: maxHeight,
             focusedOption: focusedOption
-          }), menuUI);
+          }), _this4.props['UNSAFE_is_experimental_generic'] ? /*#__PURE__*/React.createElement("div", {
+            role: "list"
+          }, menuUI) : menuUI);
         }));
       });
 

package/dist/types/components/internal/notify-open-layer-observer.d.ts

@@ -1,5 +1,7 @@
-import { useNotifyOpenLayerObserver } from '@atlaskit/layering/experimental/open-layer-observer';
-type NotifyOpenLayerObserverProps = Parameters<typeof useNotifyOpenLayerObserver>[0];
+type NotifyOpenLayerObserverProps = {
+    isOpen: boolean;
+    onClose: () => void;
+};
 /**
  * Functional component wrapper around `useNotifyOpenLayerObserver`.
  *

package/dist/types/emotion/components/containers.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+import { type ReactNode } from 'react';
+import { jsx } from '@emotion/react';
+import { type CommonPropsAndClassName, type CSSObjectWithLabel, type GroupBase } from '../../types';
+export interface ContainerProps<Option = unknown, IsMulti extends boolean = boolean, Group extends GroupBase<Option> = GroupBase<Option>> extends CommonPropsAndClassName<Option, IsMulti, Group> {
+    /**
+     * Whether the select is disabled.
+     */
+    isDisabled: boolean;
+    isFocused: boolean;
+    /**
+     * The children to be rendered.
+     */
+    children: ReactNode;
+    /**
+     * Inner props to be passed down to the container.
+     */
+    innerProps: {};
+}
+export declare const containerCSS: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>({ isDisabled, isRtl, }: ContainerProps<Option, IsMulti, Group>) => CSSObjectWithLabel;
+export declare const SelectContainer: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>(props: ContainerProps<Option, IsMulti, Group>) => jsx.JSX.Element;
+export interface ValueContainerProps<Option = unknown, IsMulti extends boolean = boolean, Group extends GroupBase<Option> = GroupBase<Option>> extends CommonPropsAndClassName<Option, IsMulti, Group> {
+    /**
+     * Props to be passed to the value container element.
+     */
+    innerProps?: {};
+    /**
+     * The children to be rendered.
+     */
+    children: ReactNode;
+    isDisabled: boolean;
+    /**
+     * Whether the select is compact.
+     */
+    isCompact?: boolean;
+}
+export declare const valueContainerCSS: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>({ isMulti, hasValue, isCompact, selectProps: { controlShouldRenderValue }, }: ValueContainerProps<Option, IsMulti, Group>) => CSSObjectWithLabel;
+export declare const ValueContainer: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>(props: ValueContainerProps<Option, IsMulti, Group>) => jsx.JSX.Element;
+export interface IndicatorsContainerProps<Option = unknown, IsMulti extends boolean = boolean, Group extends GroupBase<Option> = GroupBase<Option>> extends CommonPropsAndClassName<Option, IsMulti, Group> {
+    isDisabled: boolean;
+    /**
+     * The children to be rendered.
+     */
+    children: ReactNode;
+    /**
+     * Props to be passed to the indicators container element.
+     */
+    innerProps?: {};
+}
+export declare const indicatorsContainerCSS: () => CSSObjectWithLabel;
+export declare const IndicatorsContainer: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>(props: IndicatorsContainerProps<Option, IsMulti, Group>) => jsx.JSX.Element;

package/dist/types/emotion/components/control.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+import { type ReactNode, type Ref } from 'react';
+import { jsx } from '@emotion/react';
+import { type CommonPropsAndClassName, type CSSObjectWithLabel, type GroupBase } from '../../types';
+export interface ControlProps<Option = unknown, IsMulti extends boolean = boolean, Group extends GroupBase<Option> = GroupBase<Option>> extends CommonPropsAndClassName<Option, IsMulti, Group> {
+    /**
+     * Children to render.
+     */
+    children: ReactNode;
+    innerRef: Ref<HTMLDivElement>;
+    /**
+     * The mouse down event and the innerRef to pass down to the controller element.
+     */
+    innerProps: {};
+    /**
+     * Whether the select is disabled.
+     */
+    isDisabled: boolean;
+    /**
+     * Whether the select is focused.
+     */
+    isFocused: boolean;
+    /**
+     * Whether the select is invalid.
+     */
+    isInvalid: boolean | undefined;
+    /**
+     * Whether the select is compact.
+     */
+    isCompact?: boolean;
+    appearance?: 'default' | 'subtle' | 'none';
+    /**
+     * Whether the select is expanded.
+     */
+    menuIsOpen: boolean;
+}
+export declare const css: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>({ isDisabled, isFocused, isInvalid, isCompact, appearance, }: ControlProps<Option, IsMulti, Group>) => CSSObjectWithLabel;
+declare const Control: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>(props: ControlProps<Option, IsMulti, Group>) => jsx.JSX.Element;
+export default Control;

package/dist/types/emotion/components/group.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+import { type ComponentType, type ReactNode } from 'react';
+import { jsx } from '@emotion/react';
+import { type SelectProps } from '../../select';
+import { type CommonProps, type CommonPropsAndClassName, type CSSObjectWithLabel, type CX, type GetStyles, type GroupBase, type Options } from '../../types';
+interface ForwardedHeadingProps<Option, Group extends GroupBase<Option>> {
+    id: string;
+    data: Group;
+}
+export interface GroupProps<Option = unknown, IsMulti extends boolean = boolean, Group extends GroupBase<Option> = GroupBase<Option>> extends CommonPropsAndClassName<Option, IsMulti, Group> {
+    /**
+     * The children to be rendered.
+     */
+    children: ReactNode;
+    /**
+     * Component to wrap the label, receives headingProps.
+     */
+    Heading: ComponentType<GroupHeadingProps<Option, IsMulti, Group>>;
+    /**
+     * Props to pass to Heading.
+     */
+    headingProps: ForwardedHeadingProps<Option, Group>;
+    /**
+     * Props to be passed to the group element.
+     */
+    innerProps: JSX.IntrinsicElements['div'];
+    /**
+     * Label to be displayed in the heading component.
+     */
+    label: ReactNode;
+    /**
+     * The data of the group.
+     */
+    data: Group;
+    options: Options<Option>;
+}
+export declare const groupCSS: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>({}: GroupProps<Option, IsMulti, Group>) => CSSObjectWithLabel;
+declare const Group: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>(props: GroupProps<Option, IsMulti, Group>) => jsx.JSX.Element;
+interface GroupHeadingPropsDefinedProps<Option, IsMulti extends boolean, Group extends GroupBase<Option>> extends ForwardedHeadingProps<Option, Group> {
+    className?: string | undefined;
+    selectProps: SelectProps<Option, IsMulti, Group>;
+    getStyles: GetStyles<Option, IsMulti, Group>;
+    getClassNames: CommonProps<Option, IsMulti, Group>['getClassNames'];
+    cx: CX;
+}
+export type GroupHeadingProps<Option = unknown, IsMulti extends boolean = boolean, Group extends GroupBase<Option> = GroupBase<Option>> = GroupHeadingPropsDefinedProps<Option, IsMulti, Group> & JSX.IntrinsicElements['div'];
+export declare const groupHeadingCSS: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>({}: GroupHeadingProps<Option, IsMulti, Group>) => CSSObjectWithLabel;
+export declare const GroupHeading: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>(props: GroupHeadingProps<Option, IsMulti, Group>) => jsx.JSX.Element;
+export default Group;

package/dist/types/emotion/components/index.d.ts

@@ -0,0 +1,67 @@
+import { type ComponentType } from 'react';
+import { type GroupBase } from '../../types';
+import { type ContainerProps, type IndicatorsContainerProps, type ValueContainerProps } from './containers';
+import { type ControlProps } from './control';
+import { type GroupHeadingProps, type GroupProps } from './group';
+import { type ClearIndicatorProps, type DropdownIndicatorProps, type LoadingIndicatorProps } from './indicators';
+import { type InputProps } from './input';
+import { type MenuListProps, type MenuPortalProps, type MenuProps, type NoticeProps } from './menu';
+import { type MultiValueGenericProps, type MultiValueProps, MultiValueRemove, type MultiValueRemoveProps } from './multi-value';
+import { type OptionProps } from './option';
+import { type PlaceholderProps } from './placeholder';
+import { type SingleValueProps } from './single-value';
+export interface SelectComponents<Option, IsMulti extends boolean, Group extends GroupBase<Option>> {
+    ClearIndicator: ComponentType<ClearIndicatorProps<Option, IsMulti, Group>>;
+    Control: ComponentType<ControlProps<Option, IsMulti, Group>>;
+    DropdownIndicator: ComponentType<DropdownIndicatorProps<Option, IsMulti, Group>> | null;
+    Group: ComponentType<GroupProps<Option, IsMulti, Group>>;
+    GroupHeading: ComponentType<GroupHeadingProps<Option, IsMulti, Group>>;
+    IndicatorsContainer: ComponentType<IndicatorsContainerProps<Option, IsMulti, Group>>;
+    Input: ComponentType<InputProps<Option, IsMulti, Group>>;
+    LoadingIndicator: ComponentType<LoadingIndicatorProps<Option, IsMulti, Group>>;
+    Menu: ComponentType<MenuProps<Option, IsMulti, Group>>;
+    MenuList: ComponentType<MenuListProps<Option, IsMulti, Group>>;
+    MenuPortal: ComponentType<MenuPortalProps<Option, IsMulti, Group>>;
+    LoadingMessage: ComponentType<NoticeProps<Option, IsMulti, Group>>;
+    NoOptionsMessage: ComponentType<NoticeProps<Option, IsMulti, Group>>;
+    MultiValue: ComponentType<MultiValueProps<Option, IsMulti, Group>>;
+    MultiValueContainer: ComponentType<MultiValueGenericProps<Option, IsMulti, Group>>;
+    MultiValueLabel: ComponentType<MultiValueGenericProps<Option, IsMulti, Group>>;
+    MultiValueRemove: ComponentType<MultiValueRemoveProps<Option, IsMulti, Group>>;
+    Option: ComponentType<OptionProps<Option, IsMulti, Group>>;
+    Placeholder: ComponentType<PlaceholderProps<Option, IsMulti, Group>>;
+    SelectContainer: ComponentType<ContainerProps<Option, IsMulti, Group>>;
+    SingleValue: ComponentType<SingleValueProps<Option, IsMulti, Group>>;
+    ValueContainer: ComponentType<ValueContainerProps<Option, IsMulti, Group>>;
+}
+export type SelectComponentsConfig<Option, IsMulti extends boolean, Group extends GroupBase<Option>> = Partial<SelectComponents<Option, IsMulti, Group>>;
+export declare const components: {
+    ClearIndicator: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>(props: ClearIndicatorProps<Option, IsMulti, Group>) => import("@emotion/react").jsx.JSX.Element;
+    Control: <Option_1, IsMulti_1 extends boolean, Group_1 extends GroupBase<Option_1>>(props: ControlProps<Option_1, IsMulti_1, Group_1>) => import("@emotion/react").jsx.JSX.Element;
+    DropdownIndicator: <Option_2, IsMulti_2 extends boolean, Group_2 extends GroupBase<Option_2>>(props: DropdownIndicatorProps<Option_2, IsMulti_2, Group_2>) => import("@emotion/react").jsx.JSX.Element;
+    Group: <Option_3, IsMulti_3 extends boolean, Group_3 extends GroupBase<Option_3>>(props: GroupProps<Option_3, IsMulti_3, Group_3>) => import("@emotion/react").jsx.JSX.Element;
+    GroupHeading: <Option_4, IsMulti_4 extends boolean, Group_4 extends GroupBase<Option_4>>(props: GroupHeadingProps<Option_4, IsMulti_4, Group_4>) => import("@emotion/react").jsx.JSX.Element;
+    IndicatorsContainer: <Option_5, IsMulti_5 extends boolean, Group_5 extends GroupBase<Option_5>>(props: IndicatorsContainerProps<Option_5, IsMulti_5, Group_5>) => import("@emotion/react").jsx.JSX.Element;
+    Input: <Option_6, IsMulti_6 extends boolean, Group_6 extends GroupBase<Option_6>>(props: InputProps<Option_6, IsMulti_6, Group_6>) => import("@emotion/react").jsx.JSX.Element;
+    LoadingIndicator: <Option_7, IsMulti_7 extends boolean, Group_7 extends GroupBase<Option_7>>({ innerProps, isRtl, size, ...restProps }: LoadingIndicatorProps<Option_7, IsMulti_7, Group_7>) => import("@emotion/react").jsx.JSX.Element;
+    Menu: <Option_8, IsMulti_8 extends boolean, Group_8 extends GroupBase<Option_8>>(props: MenuProps<Option_8, IsMulti_8, Group_8>) => import("@emotion/react").jsx.JSX.Element;
+    MenuList: <Option_9, IsMulti_9 extends boolean, Group_9 extends GroupBase<Option_9>>(props: MenuListProps<Option_9, IsMulti_9, Group_9>) => import("@emotion/react").jsx.JSX.Element;
+    MenuPortal: <Option_10, IsMulti_10 extends boolean, Group_10 extends GroupBase<Option_10>>(props: MenuPortalProps<Option_10, IsMulti_10, Group_10>) => import("@emotion/react").jsx.JSX.Element | null;
+    LoadingMessage: <Option_11, IsMulti_11 extends boolean, Group_11 extends GroupBase<Option_11>>({ children, innerProps, ...restProps }: NoticeProps<Option_11, IsMulti_11, Group_11>) => import("@emotion/react").jsx.JSX.Element;
+    NoOptionsMessage: <Option_12, IsMulti_12 extends boolean, Group_12 extends GroupBase<Option_12>>({ children, innerProps, ...restProps }: NoticeProps<Option_12, IsMulti_12, Group_12>) => import("@emotion/react").jsx.JSX.Element;
+    MultiValue: <Option_13, IsMulti_13 extends boolean, Group_13 extends GroupBase<Option_13>>(props: MultiValueProps<Option_13, IsMulti_13, Group_13>) => import("@emotion/react").jsx.JSX.Element;
+    MultiValueContainer: <Option_14, IsMulti_14 extends boolean, Group_14 extends GroupBase<Option_14>>({ children, innerProps, }: MultiValueGenericProps<Option_14, IsMulti_14, Group_14>) => import("@emotion/react").jsx.JSX.Element;
+    MultiValueLabel: <Option_14, IsMulti_14 extends boolean, Group_14 extends GroupBase<Option_14>>({ children, innerProps, }: MultiValueGenericProps<Option_14, IsMulti_14, Group_14>) => import("@emotion/react").jsx.JSX.Element;
+    MultiValueRemove: typeof MultiValueRemove;
+    Option: <Option_15, IsMulti_15 extends boolean, Group_15 extends GroupBase<Option_15>>(props: OptionProps<Option_15, IsMulti_15, Group_15>) => import("@emotion/react").jsx.JSX.Element;
+    Placeholder: <Option_16, IsMulti_16 extends boolean, Group_16 extends GroupBase<Option_16>>(props: PlaceholderProps<Option_16, IsMulti_16, Group_16>) => import("@emotion/react").jsx.JSX.Element;
+    SelectContainer: <Option_17, IsMulti_17 extends boolean, Group_17 extends GroupBase<Option_17>>(props: ContainerProps<Option_17, IsMulti_17, Group_17>) => import("@emotion/react").jsx.JSX.Element;
+    SingleValue: <Option_18, IsMulti_18 extends boolean, Group_18 extends GroupBase<Option_18>>(props: SingleValueProps<Option_18, IsMulti_18, Group_18>) => import("@emotion/react").jsx.JSX.Element;
+    ValueContainer: <Option_19, IsMulti_19 extends boolean, Group_19 extends GroupBase<Option_19>>(props: ValueContainerProps<Option_19, IsMulti_19, Group_19>) => import("@emotion/react").jsx.JSX.Element;
+};
+type SelectComponentsGeneric = typeof components;
+interface ComponentsProps<Option, IsMulti extends boolean, Group extends GroupBase<Option>> {
+    components: SelectComponentsConfig<Option, IsMulti, Group>;
+}
+export declare const defaultComponents: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>(props: ComponentsProps<Option, IsMulti, Group>) => SelectComponentsGeneric;
+export {};

package/dist/types/emotion/components/indicators.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+import { type ReactNode } from 'react';
+import { jsx } from '@emotion/react';
+import { type CommonPropsAndClassName, type CSSObjectWithLabel, type GroupBase } from '../../types';
+export interface DropdownIndicatorProps<Option = unknown, IsMulti extends boolean = boolean, Group extends GroupBase<Option> = GroupBase<Option>> extends CommonPropsAndClassName<Option, IsMulti, Group> {
+    /**
+     * The children to be rendered inside the indicator.
+     */
+    children?: ReactNode;
+    /**
+     * Props that will be passed on to the children.
+     */
+    innerProps: JSX.IntrinsicElements['div'];
+    /**
+     * The focused state of the select.
+     */
+    isFocused: boolean;
+    isDisabled: boolean;
+    /**
+     * Whether the select is compact.
+     */
+    isCompact?: boolean;
+}
+export declare const dropdownIndicatorCSS: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>({ isCompact, isDisabled, }: DropdownIndicatorProps<Option, IsMulti, Group>) => CSSObjectWithLabel;
+export declare const DropdownIndicator: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>(props: DropdownIndicatorProps<Option, IsMulti, Group>) => jsx.JSX.Element;
+export interface ClearIndicatorProps<Option = unknown, IsMulti extends boolean = boolean, Group extends GroupBase<Option> = GroupBase<Option>> extends CommonPropsAndClassName<Option, IsMulti, Group> {
+    /**
+     * The children to be rendered inside the indicator.
+     */
+    children?: ReactNode;
+    /**
+     * Sets the `aria-label` for the clear icon button
+     */
+    clearControlLabel?: string;
+    /**
+     * Props that will be passed on to the children.
+     */
+    innerProps: JSX.IntrinsicElements['div'];
+    /**
+     * The focused state of the select.
+     */
+    isFocused: boolean;
+    /**
+     * Whether the select is compact.
+     */
+    isCompact?: boolean;
+}
+export declare const clearIndicatorCSS: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>({ isCompact, }: ClearIndicatorProps<Option, IsMulti, Group>) => CSSObjectWithLabel;
+export declare const ClearIndicator: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>(props: ClearIndicatorProps<Option, IsMulti, Group>) => jsx.JSX.Element;
+export declare const loadingIndicatorCSS: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>({ isCompact, }: LoadingIndicatorProps<Option, IsMulti, Group>) => CSSObjectWithLabel;
+export interface LoadingIndicatorProps<Option = unknown, IsMulti extends boolean = boolean, Group extends GroupBase<Option> = GroupBase<Option>> extends CommonPropsAndClassName<Option, IsMulti, Group> {
+    /**
+     * Props that will be passed on to the children.
+     */
+    innerProps: JSX.IntrinsicElements['div'];
+    /**
+     * The focused state of the select.
+     */
+    isFocused: boolean;
+    isDisabled: boolean;
+    /**
+     * Set size of the container.
+     */
+    size: number;
+    /**
+     * Whether the select is compact.
+     */
+    isCompact?: boolean;
+}
+export declare const LoadingIndicator: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>({ innerProps, isRtl, size, ...restProps }: LoadingIndicatorProps<Option, IsMulti, Group>) => jsx.JSX.Element;

package/dist/types/emotion/components/input.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+import { type InputHTMLAttributes } from 'react';
+import { jsx } from '@emotion/react';
+import { type CommonPropsAndClassName, type CSSObjectWithLabel, type GroupBase } from '../../types';
+interface InputSpecificProps<Option = unknown, IsMulti extends boolean = boolean, Group extends GroupBase<Option> = GroupBase<Option>> extends InputHTMLAttributes<HTMLInputElement>, CommonPropsAndClassName<Option, IsMulti, Group> {
+    /**
+     * Reference to the internal element
+     */
+    innerRef?: (instance: HTMLInputElement | null) => void;
+    /**
+     * Set whether the input should be visible. Does not affect input size.
+     */
+    isHidden: boolean;
+    /**
+     * Whether the input is disabled
+     */
+    isDisabled?: boolean;
+    /**
+     * The ID of the form that the input belongs to
+     */
+    form?: string;
+    /**
+     * Set className for the input element
+     */
+    inputClassName?: string;
+    /**
+     * A testId prop is provided for specific elements. This is a unique string that appears as a data attribute data-testid in the rendered code and serves as a hook for automated tests.
+     */
+    testId?: string;
+}
+export type InputProps<Option = unknown, IsMulti extends boolean = boolean, Group extends GroupBase<Option> = GroupBase<Option>> = InputSpecificProps<Option, IsMulti, Group>;
+export declare const inputCSS: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>({ isDisabled, value, }: InputProps<Option, IsMulti, Group>) => CSSObjectWithLabel;
+declare const Input: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>(props: InputProps<Option, IsMulti, Group>) => jsx.JSX.Element;
+export default Input;

package/dist/types/emotion/components/internal/a11y-text.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+import { jsx } from '@emotion/react';
+declare const A11yText: (props: JSX.IntrinsicElements['span']) => jsx.JSX.Element;
+export default A11yText;

package/dist/types/emotion/components/internal/dummy-input.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+import { type Ref } from 'react';
+import { jsx } from '@emotion/react';
+export default function DummyInput({ innerRef, ...props }: JSX.IntrinsicElements['input'] & {
+    readonly innerRef: Ref<HTMLInputElement>;
+}): jsx.JSX.Element;

package/dist/types/emotion/components/internal/index.d.ts

@@ -0,0 +1,4 @@
+export { default as A11yText } from './a11y-text';
+export { default as DummyInput } from './dummy-input';
+export { default as ScrollManager } from './scroll-manager';
+export { default as RequiredInput } from './required-input';

package/dist/types/emotion/components/internal/notify-open-layer-observer.d.ts

@@ -0,0 +1,11 @@
+type NotifyOpenLayerObserverProps = {
+    isOpen: boolean;
+    onClose: () => void;
+};
+/**
+ * Functional component wrapper around `useNotifyOpenLayerObserver`.
+ *
+ * This is needed as Select is a class component, which cannot use hooks directly.
+ */
+export declare function NotifyOpenLayerObserver({ isOpen, onClose }: NotifyOpenLayerObserverProps): null;
+export {};

package/dist/types/emotion/components/internal/required-input.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+import { type FocusEventHandler, type FunctionComponent } from 'react';
+declare const RequiredInput: FunctionComponent<{
+    readonly name?: string;
+    readonly onFocus: FocusEventHandler<HTMLInputElement>;
+}>;
+export default RequiredInput;

package/dist/types/emotion/components/internal/scroll-manager.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+import { type ReactElement, type RefCallback } from 'react';
+import { jsx } from '@emotion/react';
+interface ScrollManagerProps {
+    readonly children: (ref: RefCallback<HTMLElement>) => ReactElement;
+    readonly lockEnabled: boolean;
+    readonly captureEnabled: boolean;
+    readonly onBottomArrive?: (event: WheelEvent | TouchEvent) => void;
+    readonly onBottomLeave?: (event: WheelEvent | TouchEvent) => void;
+    readonly onTopArrive?: (event: WheelEvent | TouchEvent) => void;
+    readonly onTopLeave?: (event: WheelEvent | TouchEvent) => void;
+}
+export default function ScrollManager({ children, lockEnabled, captureEnabled, onBottomArrive, onBottomLeave, onTopArrive, onTopLeave, }: ScrollManagerProps): jsx.JSX.Element;
+export {};

package/dist/types/emotion/components/internal/use-scroll-capture.d.ts

@@ -0,0 +1,12 @@
+interface Options {
+    readonly isEnabled: boolean;
+    readonly onBottomArrive?: (event: WheelEvent | TouchEvent) => void;
+    readonly onBottomLeave?: (event: WheelEvent | TouchEvent) => void;
+    readonly onTopArrive?: (event: WheelEvent | TouchEvent) => void;
+    readonly onTopLeave?: (event: WheelEvent | TouchEvent) => void;
+}
+/**
+ * {description}.
+ */
+export default function useScrollCapture({ isEnabled, onBottomArrive, onBottomLeave, onTopArrive, onTopLeave, }: Options): (element: HTMLElement | null) => void;
+export {};

package/dist/types/emotion/components/internal/use-scroll-lock.d.ts

@@ -0,0 +1,9 @@
+interface Options {
+    readonly isEnabled: boolean;
+    readonly accountForScrollbars?: boolean;
+}
+/**
+ * {description}.
+ */
+export default function useScrollLock({ isEnabled, accountForScrollbars }: Options): (element: HTMLElement | null) => void;
+export {};