@atlaskit/react-select 0.0.2

package/dist/types-ts4.5/filters.d.ts

@@ -0,0 +1,15 @@
+import { type Option } from './types';
+export interface FilterOptionOption<Option> {
+    readonly label: string;
+    readonly value: string;
+    readonly data: Option;
+}
+interface Config<Option> {
+    readonly ignoreCase?: boolean;
+    readonly ignoreAccents?: boolean;
+    readonly stringify?: (option: FilterOptionOption<Option>) => string;
+    readonly trim?: boolean;
+    readonly matchFrom?: 'any' | 'start';
+}
+export declare const createFilter: (config?: Config<Option>) => (option: FilterOptionOption<Option>, rawInput: string) => boolean;
+export {};

package/dist/types-ts4.5/index.d.ts

@@ -0,0 +1,28 @@
+import type Select from './select';
+import type { GroupBase } from './types';
+import useStateManager from './use-state-manager';
+export { default } from './state-manager';
+export { default as NonceProvider } from './nonce-provider';
+export { mergeStyles } from './styles';
+export { defaultTheme } from './theme';
+export { createFilter } from './filters';
+export { components } from './components';
+export type SelectInstance<Option = unknown, IsMulti extends boolean = false, Group extends GroupBase<Option> = GroupBase<Option>> = Select<Option, IsMulti, Group>;
+export type { StateManagerProps as Props } from './use-state-manager';
+export { useStateManager };
+export type { SelectComponentsConfig } from './components';
+export type { ContainerProps, IndicatorsContainerProps, ValueContainerProps, } from './components/containers';
+export type { ControlProps } from './components/control';
+export type { GroupProps, GroupHeadingProps } from './components/group';
+export type { ClearIndicatorProps, DropdownIndicatorProps, IndicatorSeparatorProps, LoadingIndicatorProps, } from './components/indicators';
+export type { InputProps } from './components/input';
+export type { MenuListProps, MenuProps, NoticeProps } from './components/menu';
+export type { MultiValueGenericProps, MultiValueProps, MultiValueRemoveProps, } from './components/multi-value';
+export type { OptionProps } from './components/option';
+export type { PlaceholderProps } from './components/placeholder';
+export type { SingleValueProps } from './components/single-value';
+export type { ThemeConfig } from './theme';
+export type { ClassNamesConfig, StylesConfig } from './styles';
+export { type GroupBase, type OptionsOrGroups, type Option, type Options, type SingleValue, type MultiValue, type PropsValue, type OnChangeValue, type Colors, type ThemeSpacing, type Theme, type ClassNamesState, type CX, type GetStyles, type CommonProps, type CommonPropsAndClassName, type ActionMetaBase, type SelectOptionActionMeta, type DeselectOptionActionMeta, type RemoveValueActionMeta, type PopValueActionMeta, type ClearActionMeta, type CreateOptionActionMeta, type InitialInputFocusedActionMeta, type ActionMeta, type SetValueAction, type InputAction, type InputActionMeta, type MenuPlacement, type CoercedMenuPlacement, type MenuPosition, type FocusDirection, type GetOptionLabel, type GetOptionValue, type CSSObjectWithLabel, } from './types';
+export type { OptionContext, GuidanceContext, AriaGuidanceProps, AriaOnChangeProps, AriaOnFilterProps, AriaOnFocusProps, AriaLiveMessages, AriaGuidance, AriaOnChange, AriaOnFilter, AriaOnFocus, } from './accessibility';
+export type { FormatOptionLabelContext, FormatOptionLabelMeta } from './select';

package/dist/types-ts4.5/nonce-provider.d.ts

@@ -0,0 +1,8 @@
+import { type ReactNode } from 'react';
+interface NonceProviderProps {
+    nonce: string;
+    children: ReactNode;
+    cacheKey: string;
+}
+declare const NonceProvider: ({ nonce, children, cacheKey }: NonceProviderProps) => JSX.Element;
+export default NonceProvider;

package/dist/types-ts4.5/select.d.ts

@@ -0,0 +1,616 @@
+import React, { type AriaAttributes, Component, type FocusEventHandler, type FormEventHandler, type KeyboardEventHandler, type MouseEventHandler, type ReactNode, type RefCallback, type TouchEventHandler } from 'react';
+import { type AriaLiveMessages, type AriaSelection } from './accessibility';
+import { type SelectComponentsConfig } from './components';
+import { type FilterOptionOption } from './filters';
+import { type ClassNamesConfig, type StylesConfig, type StylesProps } from './styles';
+import { type ThemeConfig } from './theme';
+import { type ActionMeta, type FocusDirection, type GetOptionLabel, type GetOptionValue, type GroupBase, type InputActionMeta, type MenuPlacement, type MenuPosition, type OnChangeValue, type Options, type OptionsOrGroups, type PropsValue, type SetValueAction } from './types';
+export type FormatOptionLabelContext = 'menu' | 'value';
+export interface FormatOptionLabelMeta<Option> {
+    context: FormatOptionLabelContext;
+    inputValue: string;
+    selectValue: Options<Option>;
+}
+export interface SelectProps<Option, IsMulti extends boolean, Group extends GroupBase<Option>> {
+    /**
+     * HTML ID of an element containing an error message related to the input
+     */
+    'aria-errormessage'?: AriaAttributes['aria-errormessage'];
+    /**
+     * Indicate if the value entered in the field is invalid
+     */
+    'aria-invalid'?: AriaAttributes['aria-invalid'];
+    /**
+     * Aria label (for assistive tech)
+     */
+    'aria-label'?: AriaAttributes['aria-label'];
+    /**
+     * HTML ID of an element that should be used as the label (for assistive tech)
+     */
+    'aria-labelledby'?: AriaAttributes['aria-labelledby'];
+    'aria-describedby'?: AriaAttributes['aria-describedby'];
+    /**
+     * Used to set the priority with which screen reader should treat updates to live regions. The possible settings are: off, polite (default) or assertive
+     */
+    'aria-live'?: AriaAttributes['aria-live'];
+    /**
+     * Customise the messages used by the aria-live component
+     */
+    ariaLiveMessages?: AriaLiveMessages<Option, IsMulti, Group>;
+    /**
+     * Focus the control when it is mounted
+     */
+    autoFocus?: boolean;
+    /**
+     * Remove the currently focused option when the user presses backspace when Select isClearable or isMulti
+     */
+    backspaceRemovesValue: boolean;
+    /**
+     * Remove focus from the input when the user selects an option (handy for dismissing the keyboard on touch devices)
+     */
+    blurInputOnSelect: boolean;
+    /**
+     * When the user reaches the top/bottom of the menu, prevent scroll on the scroll-parent
+     */
+    captureMenuScroll: boolean;
+    /**
+     * Sets a className attribute on the outer component
+     */
+    className?: string;
+    /**
+     * If provided, all inner components will be given a prefixed className attribute.
+     *
+     * This is useful when styling via CSS classes instead of the Styles API approach.
+     */
+    classNamePrefix?: string | null;
+    /**
+     * Provide classNames based on state for each inner component
+     */
+    classNames: ClassNamesConfig<Option, IsMulti, Group>;
+    /**
+     * Close the select menu when the user selects an option
+     */
+    closeMenuOnSelect: boolean;
+    /**
+     * If `true`, close the select menu when the user scrolls the document/body.
+     *
+     * If a function, takes a standard javascript `ScrollEvent` you return a boolean:
+     *
+     * `true` => The menu closes
+     *
+     * `false` => The menu stays open
+     *
+     * This is useful when you have a scrollable modal and want to portal the menu out,
+     * but want to avoid graphical issues.
+     */
+    closeMenuOnScroll: boolean | ((event: Event) => boolean);
+    /**
+     * This complex object includes all the compositional components that are used
+     * in `react-select`. If you wish to overwrite a component, pass in an object
+     * with the appropriate namespace.
+     *
+     * If you only wish to restyle a component, we recommend using the `styles` prop
+     * instead. For a list of the components that can be passed in, and the shape
+     * that will be passed to them, see [the components docs](/components)
+     */
+    components: SelectComponentsConfig<Option, IsMulti, Group>;
+    /**
+     * Whether the value of the select, e.g. SingleValue, should be displayed in the control.
+     */
+    controlShouldRenderValue: boolean;
+    /**
+     * Delimiter used to join multiple values into a single HTML Input value
+     */
+    delimiter?: string;
+    /**
+     * Clear all values when the user presses escape AND the menu is closed
+     */
+    escapeClearsValue: boolean;
+    /**
+     * Custom method to filter whether an option should be displayed in the menu
+     */
+    filterOption: ((option: FilterOptionOption<Option>, inputValue: string) => boolean) | null;
+    /**
+     * Formats group labels in the menu as React components
+     *
+     * An example can be found in the [Replacing builtins](/advanced#replacing-builtins) documentation.
+     */
+    formatGroupLabel: (group: Group) => ReactNode;
+    /**
+     * Formats option labels in the menu and control as React components
+     */
+    formatOptionLabel?: (data: Option, formatOptionLabelMeta: FormatOptionLabelMeta<Option>) => ReactNode;
+    /**
+     * Resolves option data to a string to be displayed as the label by components
+     *
+     * Note: Failure to resolve to a string type can interfere with filtering and
+     * screen reader support.
+     */
+    getOptionLabel: GetOptionLabel<Option>;
+    /**
+     * Resolves option data to a string to compare options and specify value attributes
+     */
+    getOptionValue: GetOptionValue<Option>;
+    /**
+     * Hide the selected option from the menu
+     */
+    hideSelectedOptions?: boolean;
+    /**
+     * The id to set on the SelectContainer component.
+     */
+    id?: string;
+    /**
+     * The value of the search input
+     */
+    inputValue: string;
+    /**
+     * The id of the search input
+     */
+    inputId?: string;
+    /**
+     * Define an id prefix for the select components e.g. {your-id}-value
+     */
+    instanceId?: number | string;
+    /**
+     * Is the select value clearable
+     */
+    isClearable?: boolean;
+    /**
+     * Is the select disabled
+     */
+    isDisabled: boolean;
+    /**
+     * Is the select in a state of loading (async)
+     */
+    isLoading: boolean;
+    /**
+     * Override the built-in logic to detect whether an option is disabled
+     *
+     * An example can be found in the [Replacing builtins](/advanced#replacing-builtins) documentation.
+     */
+    isOptionDisabled: (option: Option, selectValue: Options<Option>) => boolean;
+    /**
+     * Override the built-in logic to detect whether an option is selected
+     */
+    isOptionSelected?: (option: Option, selectValue: Options<Option>) => boolean;
+    /**
+     * Support multiple selected options
+     */
+    isMulti: IsMulti;
+    /**
+     * Is the select direction right-to-left
+     */
+    isRtl: boolean;
+    /**
+     * Whether to enable search functionality
+     */
+    isSearchable: boolean;
+    /**
+     * Async: Text to display when loading options
+     */
+    loadingMessage: (obj: {
+        inputValue: string;
+    }) => ReactNode;
+    /**
+     * Minimum height of the menu before flipping
+     */
+    minMenuHeight: number;
+    /**
+     * Maximum height of the menu before scrolling
+     */
+    maxMenuHeight: number;
+    /**
+     * Whether the menu is open
+     */
+    menuIsOpen: boolean;
+    /**
+     * Default placement of the menu in relation to the control. 'auto' will flip
+     * when there isn't enough space below the control.
+     */
+    menuPlacement: MenuPlacement;
+    /**
+     * The CSS position value of the menu, when "fixed" extra layout management is required
+     */
+    menuPosition: MenuPosition;
+    /**
+     * Whether the menu should use a portal, and where it should attach
+     *
+     * An example can be found in the [Portaling](/advanced#portaling) documentation
+     */
+    menuPortalTarget?: HTMLElement | null;
+    /**
+     * Whether to block scroll events when the menu is open
+     */
+    menuShouldBlockScroll: boolean;
+    /**
+     * Whether the menu should be scrolled into view when it opens
+     */
+    menuShouldScrollIntoView: boolean;
+    /**
+     * Name of the HTML Input (optional - without this, no input will be rendered)
+     */
+    name?: string;
+    /**
+     * Text to display when there are no options
+     */
+    noOptionsMessage: (obj: {
+        inputValue: string;
+    }) => ReactNode;
+    /**
+     * Handle blur events on the control
+     */
+    onBlur?: FocusEventHandler<HTMLInputElement>;
+    /**
+     * Handle change events on the select
+     */
+    onChange: (newValue: OnChangeValue<Option, IsMulti>, actionMeta: ActionMeta<Option>) => void;
+    /**
+     * Handle focus events on the control
+     */
+    onFocus?: FocusEventHandler<HTMLInputElement>;
+    /**
+     * Handle change events on the input
+     */
+    onInputChange: (newValue: string, actionMeta: InputActionMeta) => void;
+    /**
+     * Handle key down events on the select
+     */
+    onKeyDown?: KeyboardEventHandler<HTMLDivElement>;
+    /**
+     * Handle the menu opening
+     */
+    onMenuOpen: () => void;
+    /**
+     * Handle the menu closing
+     */
+    onMenuClose: () => void;
+    /**
+     * Fired when the user scrolls to the top of the menu
+     */
+    onMenuScrollToTop?: (event: WheelEvent | TouchEvent) => void;
+    /**
+     * Fired when the user scrolls to the bottom of the menu
+     */
+    onMenuScrollToBottom?: (event: WheelEvent | TouchEvent) => void;
+    /**
+     * Allows control of whether the menu is opened when the Select is focused
+     */
+    openMenuOnFocus: boolean;
+    /**
+     * Allows control of whether the menu is opened when the Select is clicked
+     */
+    openMenuOnClick: boolean;
+    /**
+     * Array of options that populate the select menu
+     */
+    options: OptionsOrGroups<Option, Group>;
+    /**
+     * Number of options to jump in menu when page{up|down} keys are used
+     */
+    pageSize: number;
+    /**
+     * Placeholder for the select value
+     */
+    placeholder: ReactNode;
+    /**
+     * Status to relay to screen readers
+     */
+    screenReaderStatus: (obj: {
+        count: number;
+    }) => string;
+    /**
+     * Style modifier methods
+     *
+     * A basic example can be found at the bottom of the [Replacing builtins](/advanced#replacing-builtins) documentation.
+     */
+    styles: StylesConfig<Option, IsMulti, Group>;
+    /**
+     * Theme modifier method
+     */
+    theme?: ThemeConfig;
+    /**
+     * Sets the tabIndex attribute on the input
+     */
+    tabIndex: number;
+    /**
+     * Select the currently focused option when the user presses tab
+     */
+    tabSelectsValue: boolean;
+    /**
+     * Remove all non-essential styles
+     */
+    unstyled: boolean;
+    /**
+     * The value of the select; reflected by the selected option
+     */
+    value: PropsValue<Option>;
+    /**
+     * Sets the form attribute on the input
+     */
+    form?: string;
+    /**
+     * Marks the value-holding input as required for form validation
+     */
+    required?: boolean;
+}
+export declare const defaultProps: {
+    'aria-live': string;
+    backspaceRemovesValue: boolean;
+    blurInputOnSelect: boolean;
+    captureMenuScroll: boolean;
+    classNames: {};
+    closeMenuOnSelect: boolean;
+    closeMenuOnScroll: boolean;
+    components: {};
+    controlShouldRenderValue: boolean;
+    escapeClearsValue: boolean;
+    filterOption: (option: FilterOptionOption<import("./types").Option>, rawInput: string) => boolean;
+    formatGroupLabel: <Option, Group extends GroupBase<Option>>(group: Group) => string;
+    getOptionLabel: (option: import("./types").Option) => string;
+    getOptionValue: (option: import("./types").Option) => string;
+    isDisabled: boolean;
+    isLoading: boolean;
+    isMulti: boolean;
+    isRtl: boolean;
+    isSearchable: boolean;
+    isOptionDisabled: (option: import("./types").Option) => boolean;
+    loadingMessage: () => string;
+    maxMenuHeight: number;
+    minMenuHeight: number;
+    menuIsOpen: boolean;
+    menuPlacement: string;
+    menuPosition: string;
+    menuShouldBlockScroll: boolean;
+    menuShouldScrollIntoView: boolean;
+    noOptionsMessage: () => string;
+    openMenuOnFocus: boolean;
+    openMenuOnClick: boolean;
+    options: never[];
+    pageSize: number;
+    placeholder: string;
+    screenReaderStatus: ({ count }: {
+        count: number;
+    }) => string;
+    styles: {};
+    tabIndex: number;
+    tabSelectsValue: boolean;
+    unstyled: boolean;
+};
+interface State<Option, IsMulti extends boolean, Group extends GroupBase<Option>> {
+    ariaSelection: AriaSelection<Option, IsMulti> | null;
+    inputIsHidden: boolean;
+    isFocused: boolean;
+    focusedOption: Option | null;
+    focusedOptionId: string | null;
+    focusableOptionsWithIds: FocusableOptionWithId<Option>[];
+    focusedValue: Option | null;
+    selectValue: Options<Option>;
+    clearFocusValueOnUpdate: boolean;
+    prevWasFocused: boolean;
+    inputIsHiddenAfterUpdate: boolean | null | undefined;
+    prevProps: SelectProps<Option, IsMulti, Group> | void;
+    instancePrefix: string;
+}
+interface CategorizedOption<Option> {
+    type: 'option';
+    data: Option;
+    isDisabled: boolean;
+    isSelected: boolean;
+    label: string;
+    value: string;
+    index: number;
+}
+interface FocusableOptionWithId<Option> {
+    data: Option;
+    id: string;
+}
+interface CategorizedGroup<Option, Group extends GroupBase<Option>> {
+    type: 'group';
+    data: Group;
+    options: readonly CategorizedOption<Option>[];
+    index: number;
+}
+type CategorizedGroupOrOption<Option, Group extends GroupBase<Option>> = CategorizedGroup<Option, Group> | CategorizedOption<Option>;
+export default class Select<Option = unknown, IsMulti extends boolean = false, Group extends GroupBase<Option> = GroupBase<Option>> extends Component<SelectProps<Option, IsMulti, Group>, State<Option, IsMulti, Group>> {
+    static defaultProps: {
+        'aria-live': string;
+        backspaceRemovesValue: boolean;
+        blurInputOnSelect: boolean;
+        captureMenuScroll: boolean;
+        classNames: {};
+        closeMenuOnSelect: boolean;
+        closeMenuOnScroll: boolean;
+        components: {};
+        controlShouldRenderValue: boolean;
+        escapeClearsValue: boolean;
+        filterOption: (option: FilterOptionOption<import("./types").Option>, rawInput: string) => boolean;
+        formatGroupLabel: <Option_1, Group_1 extends GroupBase<Option_1>>(group: Group_1) => string;
+        getOptionLabel: (option: import("./types").Option) => string;
+        getOptionValue: (option: import("./types").Option) => string;
+        isDisabled: boolean;
+        isLoading: boolean;
+        isMulti: boolean;
+        isRtl: boolean;
+        isSearchable: boolean;
+        isOptionDisabled: (option: import("./types").Option) => boolean;
+        loadingMessage: () => string;
+        maxMenuHeight: number;
+        minMenuHeight: number;
+        menuIsOpen: boolean;
+        menuPlacement: string;
+        menuPosition: string;
+        menuShouldBlockScroll: boolean;
+        menuShouldScrollIntoView: boolean;
+        noOptionsMessage: () => string;
+        openMenuOnFocus: boolean;
+        openMenuOnClick: boolean;
+        options: never[];
+        pageSize: number;
+        placeholder: string;
+        screenReaderStatus: ({ count }: {
+            count: number;
+        }) => string;
+        styles: {};
+        tabIndex: number;
+        tabSelectsValue: boolean;
+        unstyled: boolean;
+    };
+    state: State<Option, IsMulti, Group>;
+    blockOptionHover: boolean;
+    isComposing: boolean;
+    commonProps: any;
+    initialTouchX: number;
+    initialTouchY: number;
+    openAfterFocus: boolean;
+    scrollToFocusedOptionOnUpdate: boolean;
+    userIsDragging?: boolean;
+    isAppleDevice: boolean;
+    controlRef: HTMLDivElement | null;
+    getControlRef: RefCallback<HTMLDivElement>;
+    focusedOptionRef: HTMLDivElement | null;
+    getFocusedOptionRef: RefCallback<HTMLDivElement>;
+    menuListRef: HTMLUListElement | null;
+    getMenuListRef: RefCallback<HTMLUListElement>;
+    inputRef: HTMLInputElement | null;
+    getInputRef: RefCallback<HTMLInputElement>;
+    constructor(props: SelectProps<Option, IsMulti, Group>);
+    static getDerivedStateFromProps(props: SelectProps<unknown, boolean, GroupBase<unknown>>, state: State<unknown, boolean, GroupBase<unknown>>): {
+        prevProps: SelectProps<unknown, boolean, GroupBase<unknown>>;
+        ariaSelection: AriaSelection<unknown, boolean> | null;
+        prevWasFocused: boolean;
+        inputIsHidden: boolean;
+        inputIsHiddenAfterUpdate: undefined;
+    } | {
+        prevProps: SelectProps<unknown, boolean, GroupBase<unknown>>;
+        ariaSelection: AriaSelection<unknown, boolean> | null;
+        prevWasFocused: boolean;
+        inputIsHidden?: undefined;
+        inputIsHiddenAfterUpdate?: undefined;
+    };
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: SelectProps<Option, IsMulti, Group>): void;
+    componentWillUnmount(): void;
+    onMenuOpen(): void;
+    onMenuClose(): void;
+    onInputChange(newValue: string, actionMeta: InputActionMeta): void;
+    focusInput(): void;
+    blurInput(): void;
+    focus: () => void;
+    blur: () => void;
+    openMenu(focusOption: 'first' | 'last'): void;
+    focusValue(direction: 'previous' | 'next'): void;
+    focusOption(direction?: FocusDirection): void;
+    onChange: (newValue: OnChangeValue<Option, IsMulti>, actionMeta: ActionMeta<Option>) => void;
+    setValue: (newValue: OnChangeValue<Option, IsMulti>, action: SetValueAction, option?: Option) => void;
+    selectOption: (newValue: Option) => void;
+    removeValue: (removedValue: Option) => void;
+    clearValue: () => void;
+    popValue: () => void;
+    getTheme(): import("./types").Theme;
+    getFocusedOptionId: (focusedOption: Option) => string | null;
+    getFocusableOptionsWithIds: () => FocusableOptionWithId<Option>[];
+    getValue: () => Options<Option>;
+    cx: (...args: any) => string;
+    getCommonProps(): {
+        clearValue: () => void;
+        cx: (...args: any) => string;
+        getStyles: <Key extends keyof StylesProps<Option, IsMulti, Group>>(key: Key, props: StylesProps<Option, IsMulti, Group>[Key]) => import("./types").CSSObjectWithLabel;
+        getClassNames: <Key_1 extends keyof StylesProps<Option, IsMulti, Group>>(key: Key_1, props: StylesProps<Option, IsMulti, Group>[Key_1]) => string | undefined;
+        getValue: () => Options<Option>;
+        hasValue: boolean;
+        isMulti: IsMulti;
+        isRtl: boolean;
+        options: OptionsOrGroups<Option, Group>;
+        selectOption: (newValue: Option) => void;
+        selectProps: Readonly<SelectProps<Option, IsMulti, Group>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        setValue: (newValue: OnChangeValue<Option, IsMulti>, action: SetValueAction, option?: Option | undefined) => void;
+        theme: import("./types").Theme;
+    };
+    getOptionLabel: (data: Option) => string;
+    getOptionValue: (data: Option) => string;
+    getStyles: <Key extends keyof StylesProps<Option, IsMulti, Group>>(key: Key, props: StylesProps<Option, IsMulti, Group>[Key]) => import("./types").CSSObjectWithLabel;
+    getClassNames: <Key extends keyof StylesProps<Option, IsMulti, Group>>(key: Key, props: StylesProps<Option, IsMulti, Group>[Key]) => string | undefined;
+    getElementId: (element: 'group' | 'input' | 'listbox' | 'option' | 'placeholder' | 'live-region') => string;
+    getComponents: () => {
+        ClearIndicator: <Option_1, IsMulti_1 extends boolean, Group_1 extends GroupBase<Option_1>>(props: import(".").ClearIndicatorProps<Option_1, IsMulti_1, Group_1>) => import("@emotion/react").jsx.JSX.Element;
+        Control: <Option_2, IsMulti_2 extends boolean, Group_2 extends GroupBase<Option_2>>(props: import(".").ControlProps<Option_2, IsMulti_2, Group_2>) => import("@emotion/react").jsx.JSX.Element;
+        DropdownIndicator: <Option_3, IsMulti_3 extends boolean, Group_3 extends GroupBase<Option_3>>(props: import(".").DropdownIndicatorProps<Option_3, IsMulti_3, Group_3>) => import("@emotion/react").jsx.JSX.Element;
+        DownChevron: (props: import("./components/indicators").DownChevronProps) => import("@emotion/react").jsx.JSX.Element;
+        CrossIcon: (props: import("./components/indicators").CrossIconProps) => import("@emotion/react").jsx.JSX.Element;
+        Group: <Option_4, IsMulti_4 extends boolean, Group_4 extends GroupBase<Option_4>>(props: import(".").GroupProps<Option_4, IsMulti_4, Group_4>) => import("@emotion/react").jsx.JSX.Element;
+        GroupHeading: <Option_5, IsMulti_5 extends boolean, Group_5 extends GroupBase<Option_5>>(props: import(".").GroupHeadingProps<Option_5, IsMulti_5, Group_5>) => import("@emotion/react").jsx.JSX.Element;
+        IndicatorsContainer: <Option_6, IsMulti_6 extends boolean, Group_6 extends GroupBase<Option_6>>(props: import(".").IndicatorsContainerProps<Option_6, IsMulti_6, Group_6>) => import("@emotion/react").jsx.JSX.Element;
+        IndicatorSeparator: <Option_7, IsMulti_7 extends boolean, Group_7 extends GroupBase<Option_7>>(props: import(".").IndicatorSeparatorProps<Option_7, IsMulti_7, Group_7>) => import("@emotion/react").jsx.JSX.Element;
+        Input: <Option_8, IsMulti_8 extends boolean, Group_8 extends GroupBase<Option_8>>(props: import(".").InputProps<Option_8, IsMulti_8, Group_8>) => import("@emotion/react").jsx.JSX.Element;
+        /**
+         * Sets a className attribute on the outer component
+         */
+        LoadingIndicator: <Option_9, IsMulti_9 extends boolean, Group_9 extends GroupBase<Option_9>>({ innerProps, isRtl, size, ...restProps }: import(".").LoadingIndicatorProps<Option_9, IsMulti_9, Group_9>) => import("@emotion/react").jsx.JSX.Element;
+        Menu: <Option_10, IsMulti_10 extends boolean, Group_10 extends GroupBase<Option_10>>(props: import("./components/menu").MenuProps<Option_10, IsMulti_10, Group_10>) => import("@emotion/react").jsx.JSX.Element;
+        MenuList: <Option_11, IsMulti_11 extends boolean, Group_11 extends GroupBase<Option_11>>(props: import("./components/menu").MenuListProps<Option_11, IsMulti_11, Group_11>) => import("@emotion/react").jsx.JSX.Element;
+        MenuPortal: <Option_12, IsMulti_12 extends boolean, Group_12 extends GroupBase<Option_12>>(props: import("./components/menu").MenuPortalProps<Option_12, IsMulti_12, Group_12>) => import("@emotion/react").jsx.JSX.Element | null;
+        LoadingMessage: <Option_13, IsMulti_13 extends boolean, Group_13 extends GroupBase<Option_13>>({ children, innerProps, ...restProps }: import("./components/menu").NoticeProps<Option_13, IsMulti_13, Group_13>) => import("@emotion/react").jsx.JSX.Element;
+        NoOptionsMessage: <Option_14, IsMulti_14 extends boolean, Group_14 extends GroupBase<Option_14>>({ children, innerProps, ...restProps }: import("./components/menu").NoticeProps<Option_14, IsMulti_14, Group_14>) => import("@emotion/react").jsx.JSX.Element;
+        MultiValue: <Option_15, IsMulti_15 extends boolean, Group_15 extends GroupBase<Option_15>>(props: import(".").MultiValueProps<Option_15, IsMulti_15, Group_15>) => import("@emotion/react").jsx.JSX.Element;
+        MultiValueContainer: <Option_16, IsMulti_16 extends boolean, Group_16 extends GroupBase<Option_16>>({ children, innerProps, }: import(".").MultiValueGenericProps<Option_16, IsMulti_16, Group_16>) => import("@emotion/react").jsx.JSX.Element;
+        MultiValueLabel: <Option_16, IsMulti_16 extends boolean, Group_16 extends GroupBase<Option_16>>({ children, innerProps, }: import(".").MultiValueGenericProps<Option_16, IsMulti_16, Group_16>) => import("@emotion/react").jsx.JSX.Element;
+        MultiValueRemove: typeof import("./components/multi-value").MultiValueRemove;
+        Option: <Option_17, IsMulti_17 extends boolean, Group_17 extends GroupBase<Option_17>>(props: import(".").OptionProps<Option_17, IsMulti_17, Group_17>) => import("@emotion/react").jsx.JSX.Element;
+        Placeholder: <Option_18, IsMulti_18 extends boolean, Group_18 extends GroupBase<Option_18>>(props: import(".").PlaceholderProps<Option_18, IsMulti_18, Group_18>) => import("@emotion/react").jsx.JSX.Element;
+        SelectContainer: <Option_19, IsMulti_19 extends boolean, Group_19 extends GroupBase<Option_19>>(props: import(".").ContainerProps<Option_19, IsMulti_19, Group_19>) => import("@emotion/react").jsx.JSX.Element;
+        SingleValue: <Option_20, IsMulti_20 extends boolean, Group_20 extends GroupBase<Option_20>>(props: import(".").SingleValueProps<Option_20, IsMulti_20, Group_20>) => import("@emotion/react").jsx.JSX.Element;
+        ValueContainer: <Option_21, IsMulti_21 extends boolean, Group_21 extends GroupBase<Option_21>>(props: import(".").ValueContainerProps<Option_21, IsMulti_21, Group_21>) => import("@emotion/react").jsx.JSX.Element;
+    };
+    buildCategorizedOptions: () => CategorizedGroupOrOption<Option, Group>[];
+    getCategorizedOptions: () => CategorizedGroupOrOption<Option, Group>[];
+    buildFocusableOptions: () => Option[];
+    getFocusableOptions: () => Option[];
+    ariaOnChange: (value: OnChangeValue<Option, IsMulti>, actionMeta: ActionMeta<Option>) => void;
+    hasValue(): boolean;
+    hasOptions(): boolean;
+    isClearable(): boolean;
+    isOptionDisabled(option: Option, selectValue: Options<Option>): boolean;
+    isOptionSelected(option: Option, selectValue: Options<Option>): boolean;
+    filterOption(option: FilterOptionOption<Option>, inputValue: string): boolean;
+    formatOptionLabel(data: Option, context: FormatOptionLabelContext): ReactNode;
+    formatGroupLabel(data: Group): React.ReactNode;
+    onMenuMouseDown: MouseEventHandler<HTMLDivElement>;
+    onMenuMouseMove: MouseEventHandler<HTMLDivElement>;
+    onControlMouseDown: (event: React.MouseEvent<HTMLDivElement> | React.TouchEvent<HTMLDivElement>) => void;
+    onDropdownIndicatorMouseDown: (event: React.MouseEvent<HTMLDivElement> | React.TouchEvent<HTMLDivElement>) => void;
+    onClearIndicatorMouseDown: (event: React.MouseEvent<HTMLDivElement> | React.TouchEvent<HTMLDivElement>) => void;
+    onScroll: (event: Event) => void;
+    startListeningComposition(): void;
+    stopListeningComposition(): void;
+    onCompositionStart: () => void;
+    onCompositionEnd: () => void;
+    startListeningToTouch(): void;
+    stopListeningToTouch(): void;
+    onTouchStart: ({ touches }: TouchEvent) => void;
+    onTouchMove: ({ touches }: TouchEvent) => void;
+    onTouchEnd: (event: TouchEvent) => void;
+    onControlTouchEnd: TouchEventHandler<HTMLDivElement>;
+    onClearIndicatorTouchEnd: TouchEventHandler<HTMLDivElement>;
+    onDropdownIndicatorTouchEnd: TouchEventHandler<HTMLDivElement>;
+    handleInputChange: FormEventHandler<HTMLInputElement>;
+    onInputFocus: FocusEventHandler<HTMLInputElement>;
+    onInputBlur: FocusEventHandler<HTMLInputElement>;
+    onOptionHover: (focusedOption: Option) => void;
+    shouldHideSelectedOptions: () => boolean;
+    onValueInputFocus: FocusEventHandler;
+    onKeyDown: KeyboardEventHandler<HTMLDivElement>;
+    renderInput(): JSX.Element;
+    renderPlaceholderOrValue(): JSX.Element | JSX.Element[] | null;
+    renderClearIndicator(): JSX.Element | null;
+    renderLoadingIndicator(): JSX.Element | null;
+    renderIndicatorSeparator(): JSX.Element | null;
+    renderDropdownIndicator(): JSX.Element | null;
+    renderMenu(): JSX.Element | null;
+    renderFormField(): JSX.Element | undefined;
+    renderLiveRegion(): JSX.Element;
+    render(): JSX.Element;
+}
+export type PublicBaseSelectProps<Option, IsMulti extends boolean, Group extends GroupBase<Option>> = JSX.LibraryManagedAttributes<typeof Select, SelectProps<Option, IsMulti, Group>>;
+export {};