@atlaskit/react-select 0.0.2

package/dist/types/styles.d.ts

@@ -0,0 +1,68 @@
+import { type ContainerProps, type IndicatorsContainerProps, type ValueContainerProps } from './components/containers';
+import { type ControlProps } from './components/control';
+import { type GroupHeadingProps, type GroupProps } from './components/group';
+import { type ClearIndicatorProps, type DropdownIndicatorProps, type IndicatorSeparatorProps, type LoadingIndicatorProps } from './components/indicators';
+import { type InputProps } from './components/input';
+import { type MenuListProps, type MenuProps, type NoticeProps, type PortalStyleArgs } from './components/menu';
+import { type MultiValueProps } from './components/multi-value';
+import { type OptionProps } from './components/option';
+import { type PlaceholderProps } from './components/placeholder';
+import { type SingleValueProps } from './components/single-value';
+import { type CSSObjectWithLabel, type GroupBase } from './types';
+export interface StylesProps<Option, IsMulti extends boolean, Group extends GroupBase<Option>> {
+    clearIndicator: ClearIndicatorProps<Option, IsMulti, Group>;
+    container: ContainerProps<Option, IsMulti, Group>;
+    control: ControlProps<Option, IsMulti, Group>;
+    dropdownIndicator: DropdownIndicatorProps<Option, IsMulti, Group>;
+    group: GroupProps<Option, IsMulti, Group>;
+    groupHeading: GroupHeadingProps<Option, IsMulti, Group>;
+    indicatorsContainer: IndicatorsContainerProps<Option, IsMulti, Group>;
+    indicatorSeparator: IndicatorSeparatorProps<Option, IsMulti, Group>;
+    input: InputProps<Option, IsMulti, Group>;
+    loadingIndicator: LoadingIndicatorProps<Option, IsMulti, Group>;
+    loadingMessage: NoticeProps<Option, IsMulti, Group>;
+    menu: MenuProps<Option, IsMulti, Group>;
+    menuList: MenuListProps<Option, IsMulti, Group>;
+    menuPortal: PortalStyleArgs;
+    multiValue: MultiValueProps<Option, IsMulti, Group>;
+    multiValueLabel: MultiValueProps<Option, IsMulti, Group>;
+    multiValueRemove: MultiValueProps<Option, IsMulti, Group>;
+    noOptionsMessage: NoticeProps<Option, IsMulti, Group>;
+    option: OptionProps<Option, IsMulti, Group>;
+    placeholder: PlaceholderProps<Option, IsMulti, Group>;
+    singleValue: SingleValueProps<Option, IsMulti, Group>;
+    valueContainer: ValueContainerProps<Option, IsMulti, Group>;
+}
+export declare const defaultStyles: {
+    [K in keyof StylesProps<any, any, any>]: (props: StylesProps<unknown, boolean, GroupBase<unknown>>[K], unstyled: boolean) => CSSObjectWithLabel;
+};
+export type StylesConfig<Option = unknown, IsMulti extends boolean = boolean, Group extends GroupBase<Option> = GroupBase<Option>> = {
+    [K in keyof StylesProps<Option, IsMulti, Group>]?: (base: CSSObjectWithLabel, props: StylesProps<Option, IsMulti, Group>[K]) => CSSObjectWithLabel;
+};
+export type ClassNamesConfig<Option = unknown, IsMulti extends boolean = boolean, Group extends GroupBase<Option> = GroupBase<Option>> = {
+    [K in keyof StylesProps<Option, IsMulti, Group>]?: (props: StylesProps<Option, IsMulti, Group>[K]) => string;
+};
+export declare function mergeStyles<Option, IsMulti extends boolean, Group extends GroupBase<Option>>(source: StylesConfig<Option, IsMulti, Group>, target?: StylesConfig<Option, IsMulti, Group>): {
+    clearIndicator?: ((base: CSSObjectWithLabel, props: ClearIndicatorProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    container?: ((base: CSSObjectWithLabel, props: ContainerProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    control?: ((base: CSSObjectWithLabel, props: ControlProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    dropdownIndicator?: ((base: CSSObjectWithLabel, props: DropdownIndicatorProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    group?: ((base: CSSObjectWithLabel, props: GroupProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    groupHeading?: ((base: CSSObjectWithLabel, props: GroupHeadingProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    indicatorsContainer?: ((base: CSSObjectWithLabel, props: IndicatorsContainerProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    indicatorSeparator?: ((base: CSSObjectWithLabel, props: IndicatorSeparatorProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    input?: ((base: CSSObjectWithLabel, props: InputProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    loadingIndicator?: ((base: CSSObjectWithLabel, props: LoadingIndicatorProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    loadingMessage?: ((base: CSSObjectWithLabel, props: NoticeProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    menu?: ((base: CSSObjectWithLabel, props: MenuProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    menuList?: ((base: CSSObjectWithLabel, props: MenuListProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    menuPortal?: ((base: CSSObjectWithLabel, props: PortalStyleArgs) => CSSObjectWithLabel) | undefined;
+    multiValue?: ((base: CSSObjectWithLabel, props: MultiValueProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    multiValueLabel?: ((base: CSSObjectWithLabel, props: MultiValueProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    multiValueRemove?: ((base: CSSObjectWithLabel, props: MultiValueProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    noOptionsMessage?: ((base: CSSObjectWithLabel, props: NoticeProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    option?: ((base: CSSObjectWithLabel, props: OptionProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    placeholder?: ((base: CSSObjectWithLabel, props: PlaceholderProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    singleValue?: ((base: CSSObjectWithLabel, props: SingleValueProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+    valueContainer?: ((base: CSSObjectWithLabel, props: ValueContainerProps<Option, IsMulti, Group>) => CSSObjectWithLabel) | undefined;
+};

package/dist/types/theme.d.ts

@@ -0,0 +1,27 @@
+import { type Theme } from './types';
+export declare const colors: {
+    primary: string;
+    primary75: string;
+    primary50: string;
+    primary25: string;
+    danger: string;
+    dangerLight: string;
+    neutral0: string;
+    neutral5: string;
+    neutral10: string;
+    neutral20: string;
+    neutral30: string;
+    neutral40: string;
+    neutral50: string;
+    neutral60: string;
+    neutral70: string;
+    neutral80: string;
+    neutral90: string;
+};
+export declare const spacing: {
+    baseUnit: number;
+    controlHeight: number;
+    menuGutter: number;
+};
+export declare const defaultTheme: Theme;
+export type ThemeConfig = Theme | ((theme: Theme) => Theme);

package/dist/types/types.d.ts

@@ -0,0 +1,134 @@
+import { type CSSObject } from '@emotion/react';
+import { type SelectProps } from './select';
+import { type StylesProps } from './styles';
+export interface GroupBase<Option> {
+    readonly options: readonly Option[];
+    readonly label?: string;
+}
+export interface Option {
+    label: string;
+    value: string;
+}
+export type OptionsOrGroups<Option, Group extends GroupBase<Option>> = readonly (Option | Group)[];
+export type Options<Option> = readonly Option[];
+export type SingleValue<Option> = Option | null;
+export type MultiValue<Option> = readonly Option[];
+export type PropsValue<Option> = MultiValue<Option> | SingleValue<Option>;
+export type OnChangeValue<Option, IsMulti extends boolean> = IsMulti extends true ? MultiValue<Option> : SingleValue<Option>;
+export interface Colors {
+    primary: string;
+    primary75: string;
+    primary50: string;
+    primary25: string;
+    danger: string;
+    dangerLight: string;
+    neutral0: string;
+    neutral5: string;
+    neutral10: string;
+    neutral20: string;
+    neutral30: string;
+    neutral40: string;
+    neutral50: string;
+    neutral60: string;
+    neutral70: string;
+    neutral80: string;
+    neutral90: string;
+}
+export interface ThemeSpacing {
+    baseUnit: number;
+    controlHeight: number;
+    menuGutter: number;
+}
+export interface Theme {
+    borderRadius: number;
+    colors: Colors;
+    spacing: ThemeSpacing;
+}
+export type ClassNamesState = {
+    [key: string]: boolean;
+};
+export type CX = (state: ClassNamesState, ...classNames: (string | undefined)[]) => string;
+export type GetStyles<Option, IsMulti extends boolean, Group extends GroupBase<Option>> = <Key extends keyof StylesProps<Option, IsMulti, Group>>(propertyName: Key, props: StylesProps<Option, IsMulti, Group>[Key]) => CSSObjectWithLabel;
+export interface CommonProps<Option, IsMulti extends boolean, Group extends GroupBase<Option>> {
+    clearValue: () => void;
+    cx: CX;
+    /**
+     * Get the styles of a particular part of the select. Pass in the name of the
+     * property as the first argument, and the current props as the second argument.
+     * See the `styles` object for the properties available.
+     */
+    getStyles: GetStyles<Option, IsMulti, Group>;
+    getClassNames: <Key extends keyof StylesProps<Option, IsMulti, Group>>(propertyName: Key, props: StylesProps<Option, IsMulti, Group>[Key]) => string | undefined;
+    getValue: () => Options<Option>;
+    hasValue: boolean;
+    isMulti: boolean;
+    isRtl: boolean;
+    options: OptionsOrGroups<Option, Group>;
+    selectOption: (newValue: Option) => void;
+    selectProps: SelectProps<Option, IsMulti, Group>;
+    setValue: (newValue: OnChangeValue<Option, IsMulti>, action: SetValueAction, option?: Option) => void;
+    theme: Theme;
+}
+export interface CommonPropsAndClassName<Option, IsMulti extends boolean, Group extends GroupBase<Option>> extends CommonProps<Option, IsMulti, Group> {
+    className?: string | undefined;
+}
+export interface ActionMetaBase<Option> {
+    option?: Option | undefined;
+    removedValue?: Option;
+    removedValues?: Options<Option>;
+    name?: string;
+}
+export interface SelectOptionActionMeta<Option> extends ActionMetaBase<Option> {
+    action: 'select-option';
+    option: Option | undefined;
+    name?: string;
+}
+export interface DeselectOptionActionMeta<Option> extends ActionMetaBase<Option> {
+    action: 'deselect-option';
+    option: Option | undefined;
+    name?: string;
+}
+export interface RemoveValueActionMeta<Option> extends ActionMetaBase<Option> {
+    action: 'remove-value';
+    removedValue: Option;
+    name?: string;
+}
+export interface PopValueActionMeta<Option> extends ActionMetaBase<Option> {
+    action: 'pop-value';
+    removedValue: Option;
+    name?: string;
+}
+export interface ClearActionMeta<Option> extends ActionMetaBase<Option> {
+    action: 'clear';
+    removedValues: Options<Option>;
+    name?: string;
+}
+export interface CreateOptionActionMeta<Option> extends ActionMetaBase<Option> {
+    action: 'create-option';
+    name?: string;
+    option: Option;
+}
+export interface InitialInputFocusedActionMeta<Option, IsMulti extends boolean> extends ActionMetaBase<Option> {
+    action: 'initial-input-focus';
+    value: OnChangeValue<Option, IsMulti>;
+    options?: Options<Option>;
+}
+export type ActionMeta<Option> = SelectOptionActionMeta<Option> | DeselectOptionActionMeta<Option> | RemoveValueActionMeta<Option> | PopValueActionMeta<Option> | ClearActionMeta<Option> | CreateOptionActionMeta<Option>;
+export type SetValueAction = 'select-option' | 'deselect-option';
+export type InputAction = 'set-value' | 'input-change' | 'input-blur' | 'menu-close';
+export interface InputActionMeta {
+    action: InputAction;
+    /**
+     * The previous value of the search input.
+     */
+    prevInputValue: string;
+}
+export type MenuPlacement = 'auto' | 'bottom' | 'top';
+export type CoercedMenuPlacement = 'bottom' | 'top';
+export type MenuPosition = 'absolute' | 'fixed';
+export type FocusDirection = 'up' | 'down' | 'pageup' | 'pagedown' | 'first' | 'last';
+export type GetOptionLabel<Option> = (option: Option) => string;
+export type GetOptionValue<Option> = (option: Option) => string;
+export type CSSObjectWithLabel = CSSObject & {
+    label?: string;
+};

package/dist/types/use-async.d.ts

@@ -0,0 +1,31 @@
+import { type GroupBase, type OptionsOrGroups } from './types';
+import { type StateManagerProps } from './use-state-manager';
+type AsyncManagedPropKeys = 'options' | 'isLoading' | 'onInputChange' | 'filterOption';
+export interface AsyncAdditionalProps<Option, Group extends GroupBase<Option>> {
+    /**
+     * The default set of options to show before the user starts searching. When
+     * set to `true`, the results for loadOptions('') will be autoloaded.
+     */
+    defaultOptions?: OptionsOrGroups<Option, Group> | boolean;
+    /**
+     * If cacheOptions is truthy, then the loaded data will be cached. The cache
+     * will remain until `cacheOptions` changes value.
+     */
+    cacheOptions?: any;
+    /**
+     * Function that returns a promise, which is the set of options to be used
+     * once the promise resolves.
+     */
+    loadOptions?: (inputValue: string, callback: (options: OptionsOrGroups<Option, Group>) => void) => Promise<OptionsOrGroups<Option, Group>> | void;
+    /**
+     * Will cause the select to be displayed in the loading state, even if the
+     * Async select is not currently waiting for loadOptions to resolve
+     */
+    isLoading?: boolean;
+}
+export type AsyncProps<Option, IsMulti extends boolean, Group extends GroupBase<Option>> = StateManagerProps<Option, IsMulti, Group> & AsyncAdditionalProps<Option, Group>;
+/**
+ * {description}.
+ */
+export default function useAsync<Option, IsMulti extends boolean, Group extends GroupBase<Option>, AdditionalProps>({ defaultOptions: propsDefaultOptions, cacheOptions, loadOptions: propsLoadOptions, options: propsOptions, isLoading: propsIsLoading, onInputChange: propsOnInputChange, filterOption, ...restSelectProps }: AsyncProps<Option, IsMulti, Group> & AdditionalProps): StateManagerProps<Option, IsMulti, Group> & Omit<AdditionalProps, keyof AsyncAdditionalProps<Option, Group> | AsyncManagedPropKeys>;
+export {};

package/dist/types/use-creatable.d.ts

@@ -0,0 +1,46 @@
+import { type ReactNode } from 'react';
+import { type PublicBaseSelectProps } from './select';
+import { type GetOptionLabel, type GetOptionValue, type GroupBase, type Options, type OptionsOrGroups } from './types';
+export interface Accessors<Option> {
+    getOptionValue: GetOptionValue<Option>;
+    getOptionLabel: GetOptionLabel<Option>;
+}
+export interface CreatableAdditionalProps<Option, Group extends GroupBase<Option>> {
+    /**
+     * Allow options to be created while the `isLoading` prop is true. Useful to
+     * prevent the "create new ..." option being displayed while async results are
+     * still being loaded.
+     */
+    allowCreateWhileLoading?: boolean;
+    /**
+     * Sets the position of the createOption element in your options list. Defaults to 'last'
+     */
+    createOptionPosition?: 'first' | 'last';
+    /**
+     * Gets the label for the "create new ..." option in the menu. Is given the
+     * current input value.
+     */
+    formatCreateLabel?: (inputValue: string) => ReactNode;
+    /**
+     * Determines whether the "create new ..." option should be displayed based on
+     * the current input value, select value and options array.
+     */
+    isValidNewOption?: (inputValue: string, value: Options<Option>, options: OptionsOrGroups<Option, Group>, accessors: Accessors<Option>) => boolean;
+    /**
+     * Returns the data for the new option when it is created. Used to display the
+     * value, and is passed to `onChange`.
+     */
+    getNewOptionData?: (inputValue: string, optionLabel: ReactNode) => Option;
+    /**
+     * If provided, this will be called with the input value when a new option is
+     * created, and `onChange` will **not** be called. Use this when you need more
+     * control over what happens when new options are created.
+     */
+    onCreateOption?: (inputValue: string) => void;
+}
+type BaseCreatableProps<Option, IsMulti extends boolean, Group extends GroupBase<Option>> = PublicBaseSelectProps<Option, IsMulti, Group> & CreatableAdditionalProps<Option, Group>;
+/**
+ * {description}.
+ */
+export default function useCreatable<Option, IsMulti extends boolean, Group extends GroupBase<Option>>({ allowCreateWhileLoading, createOptionPosition, formatCreateLabel, isValidNewOption, getNewOptionData, onCreateOption, options: propsOptions, onChange: propsOnChange, ...restSelectProps }: BaseCreatableProps<Option, IsMulti, Group>): PublicBaseSelectProps<Option, IsMulti, Group>;
+export {};

package/dist/types/use-state-manager.d.ts

@@ -0,0 +1,15 @@
+import { type PublicBaseSelectProps } from './select';
+import { type GroupBase, type PropsValue } from './types';
+type StateManagedPropKeys = 'inputValue' | 'menuIsOpen' | 'onChange' | 'onInputChange' | 'onMenuClose' | 'onMenuOpen' | 'value';
+type SelectPropsWithOptionalStateManagedProps<Option, IsMulti extends boolean, Group extends GroupBase<Option>> = Omit<PublicBaseSelectProps<Option, IsMulti, Group>, StateManagedPropKeys> & Partial<PublicBaseSelectProps<Option, IsMulti, Group>>;
+export interface StateManagerAdditionalProps<Option> {
+    defaultInputValue?: string;
+    defaultMenuIsOpen?: boolean;
+    defaultValue?: PropsValue<Option>;
+}
+export type StateManagerProps<Option = unknown, IsMulti extends boolean = boolean, Group extends GroupBase<Option> = GroupBase<Option>> = SelectPropsWithOptionalStateManagedProps<Option, IsMulti, Group> & StateManagerAdditionalProps<Option>;
+/**
+ * {description}.
+ */
+export default function useStateManager<Option, IsMulti extends boolean, Group extends GroupBase<Option>, AdditionalProps>({ defaultInputValue, defaultMenuIsOpen, defaultValue, inputValue: propsInputValue, menuIsOpen: propsMenuIsOpen, onChange: propsOnChange, onInputChange: propsOnInputChange, onMenuClose: propsOnMenuClose, onMenuOpen: propsOnMenuOpen, value: propsValue, ...restSelectProps }: StateManagerProps<Option, IsMulti, Group> & AdditionalProps): PublicBaseSelectProps<Option, IsMulti, Group> & Omit<AdditionalProps, keyof StateManagerAdditionalProps<Option> | StateManagedPropKeys>;
+export {};

package/dist/types/utils.d.ts

@@ -0,0 +1,44 @@
+import type { StylesProps } from './styles';
+import type { ClassNamesState, CommonPropsAndClassName, GroupBase, InputActionMeta, MultiValue, OnChangeValue, Option, Options, PropsValue, SingleValue } from './types';
+export declare const noop: () => void;
+export declare const emptyString: () => string;
+export declare function classNames(prefix?: string | null, state?: ClassNamesState, ...classNameList: string[]): string;
+export declare const cleanValue: (value: PropsValue<Option>) => Options<Option>;
+export declare const cleanCommonProps: <Option, IsMulti extends boolean, Group extends GroupBase<Option>, AdditionalProps>(props: Partial<CommonPropsAndClassName<Option, IsMulti, Group>> & AdditionalProps) => Omit<AdditionalProps, keyof CommonPropsAndClassName<Option, IsMulti, Group>>;
+export declare const getStyleProps: <Option, IsMulti extends boolean, Group extends GroupBase<Option>, Key extends keyof StylesProps<Option, IsMulti, Group>>(props: Pick<CommonPropsAndClassName<Option, IsMulti, Group>, 'cx' | 'getStyles' | 'getClassNames' | 'className'> & StylesProps<Option, IsMulti, Group>[Key], name: Key, classNamesState?: ClassNamesState) => {
+    css: import("./types").CSSObjectWithLabel;
+    className: string;
+};
+export declare function handleInputChange(inputValue: string, actionMeta: InputActionMeta, onInputChange?: (newValue: string, actionMeta: InputActionMeta) => string | void): string;
+export declare function isDocumentElement(el: HTMLElement | typeof window): el is typeof window;
+export declare function normalizedHeight(el: HTMLElement | typeof window): number;
+export declare function getScrollTop(el: HTMLElement | typeof window): number;
+export declare function scrollTo(el: HTMLElement | typeof window, top: number): void;
+export declare function getScrollParent(element: HTMLElement): HTMLElement;
+export declare function animatedScrollTo(element: HTMLElement | typeof window, to: number, duration?: number, callback?: (element: HTMLElement | typeof window) => void): void;
+export declare function scrollIntoView(menuEl: HTMLElement, focusedEl: HTMLElement): void;
+export declare function getBoundingClientObj(element: HTMLElement): {
+    bottom: number;
+    height: number;
+    left: number;
+    right: number;
+    top: number;
+    width: number;
+};
+export interface Rect {
+    left: number;
+    right: number;
+    bottom: number;
+    height: number;
+    width: number;
+}
+export declare function toKey(str: string): string;
+export declare function isTouchCapable(): boolean;
+export declare function isMobileDevice(): boolean;
+export declare const supportsPassiveEvents: boolean;
+export declare function notNullish<T>(item: T | null | undefined): item is T;
+export declare function isArray<T>(arg: unknown): arg is readonly T[];
+export declare function valueTernary<Option, IsMulti extends boolean>(isMulti: IsMulti | undefined, multiValue: MultiValue<Option>, singleValue: SingleValue<Option>): OnChangeValue<Option, IsMulti>;
+export declare function singleValueAsValue<Option, IsMulti extends boolean>(singleValue: SingleValue<Option>): OnChangeValue<Option, IsMulti>;
+export declare function multiValueAsValue<Option, IsMulti extends boolean>(multiValue: MultiValue<Option>): OnChangeValue<Option, IsMulti>;
+export declare const removeProps: <Props extends object, K extends string[]>(propsObj: Props, ...properties: K) => Omit<Props, K[number]>;

package/dist/types-ts4.5/accessibility/helpers.d.ts

@@ -0,0 +1,5 @@
+export declare function isIPhone(): boolean;
+export declare function isMac(): boolean;
+export declare function isIPad(): boolean;
+export declare function isIOS(): boolean;
+export declare function isAppleDevice(): boolean;

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

@@ -0,0 +1,125 @@
+import type { AriaAttributes } from 'react';
+import { type ActionMeta, type GroupBase, type InitialInputFocusedActionMeta, type OnChangeValue, type Options, type OptionsOrGroups } from '../types';
+export type OptionContext = 'menu' | 'value';
+export type GuidanceContext = 'menu' | 'input' | 'value';
+export type AriaSelection<Option, IsMulti extends boolean> = InitialInputFocusedActionMeta<Option, IsMulti> | (ActionMeta<Option> & {
+    value: OnChangeValue<Option, IsMulti>;
+    option?: Option;
+    options?: Options<Option>;
+});
+export interface AriaGuidanceProps {
+    /**
+     * String value of selectProp aria-label
+     */
+    'aria-label': AriaAttributes['aria-label'];
+    /**
+     * String indicating user's current context and available keyboard interactivity
+     */
+    context: GuidanceContext;
+    /**
+     * Boolean value of selectProp isSearchable
+     */
+    isSearchable: boolean;
+    /**
+     * Boolean value of selectProp isMulti
+     */
+    isMulti: boolean;
+    /**
+     * Boolean value of selectProp isDisabled
+     */
+    isDisabled: boolean | null;
+    /**
+     * Boolean value of selectProp tabSelectsValue
+     */
+    tabSelectsValue: boolean;
+    /**
+     * Boolean value indicating if user focused the input for the first time
+     */
+    isInitialFocus: boolean;
+}
+export type AriaOnChangeProps<Option, IsMulti extends boolean> = AriaSelection<Option, IsMulti> & {
+    /**
+     * String derived label from selected or removed option/value
+     */
+    label: string;
+    /**
+     * Array of labels derived from multiple selected or cleared options
+     */
+    labels: string[];
+    /**
+     * Boolean indicating if the selected menu option is disabled
+     */
+    isDisabled: boolean | null;
+};
+export interface AriaOnFilterProps {
+    /**
+     * String indicating current inputValue of the input
+     */
+    inputValue: string;
+    /**
+     * String derived from selectProp screenReaderStatus
+     */
+    resultsMessage: string;
+}
+export interface AriaOnFocusProps<Option, Group extends GroupBase<Option>> {
+    /**
+     * String indicating whether the option was focused in the menu or as (multi-) value
+     */
+    context: OptionContext;
+    /**
+     * Option that is being focused
+     */
+    focused: Option;
+    /**
+     * Boolean indicating whether focused menu option has been disabled
+     */
+    isDisabled: boolean;
+    /**
+     * Boolean indicating whether focused menu option is an already selected option
+     */
+    isSelected: boolean;
+    /**
+     * String derived label from focused option/value
+     */
+    label: string;
+    /**
+     * Options provided as props to Select used to determine indexing
+     */
+    options: OptionsOrGroups<Option, Group>;
+    /**
+     * selected option(s) of the Select
+     */
+    selectValue: Options<Option>;
+    /**
+     * Boolean indicating whether user uses Apple device
+     */
+    isAppleDevice: boolean;
+}
+export type AriaGuidance = (props: AriaGuidanceProps) => string;
+export type AriaOnChange<Option, IsMulti extends boolean> = (props: AriaOnChangeProps<Option, IsMulti>) => string;
+export type AriaOnFilter = (props: AriaOnFilterProps) => string;
+export type AriaOnFocus<Option, Group extends GroupBase<Option> = GroupBase<Option>> = (props: AriaOnFocusProps<Option, Group>) => string;
+export interface AriaLiveMessages<Option, IsMulti extends boolean, Group extends GroupBase<Option>> {
+    /**
+     * Guidance message used to convey component state and specific keyboard interactivity
+     */
+    guidance?: (props: AriaGuidanceProps) => string;
+    /**
+     * OnChange message used to convey changes to value but also called when user selects disabled option
+     */
+    onChange?: (props: AriaOnChangeProps<Option, IsMulti>) => string;
+    /**
+     * OnFilter message used to convey information about filtered results displayed in the menu
+     */
+    onFilter?: (props: AriaOnFilterProps) => string;
+    /**
+     * OnFocus message used to convey information about the currently focused option or value
+     */
+    onFocus?: (props: AriaOnFocusProps<Option, Group>) => string;
+}
+export declare const defaultAriaLiveMessages: {
+    guidance: (props: AriaGuidanceProps) => string;
+    onChange: <Option, IsMulti extends boolean>(props: AriaOnChangeProps<Option, IsMulti>) => string;
+    onFocus: <Option_1, Group extends GroupBase<Option_1>>(props: AriaOnFocusProps<Option_1, Group>) => string;
+    onFilter: (props: AriaOnFilterProps) => string;
+};

package/dist/types-ts4.5/async-creatable.d.ts

@@ -0,0 +1,10 @@
+import { type ReactElement, type RefAttributes } from 'react';
+import Select from './select';
+import { type GroupBase } from './types';
+import { type AsyncAdditionalProps } from './use-async';
+import { type CreatableAdditionalProps } from './use-creatable';
+import { type StateManagerProps } from './use-state-manager';
+export type AsyncCreatableProps<Option, IsMulti extends boolean, Group extends GroupBase<Option>> = StateManagerProps<Option, IsMulti, Group> & CreatableAdditionalProps<Option, Group> & AsyncAdditionalProps<Option, Group>;
+type AsyncCreatableSelect = <Option = unknown, IsMulti extends boolean = false, Group extends GroupBase<Option> = GroupBase<Option>>(props: AsyncCreatableProps<Option, IsMulti, Group> & RefAttributes<Select<Option, IsMulti, Group>>) => ReactElement;
+declare const AsyncCreatableSelect: AsyncCreatableSelect;
+export default AsyncCreatableSelect;

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

@@ -0,0 +1,9 @@
+import { type ReactElement, type RefAttributes } from 'react';
+import Select from './select';
+import { type GroupBase } from './types';
+import useAsync, { type AsyncProps } from './use-async';
+export type { AsyncProps };
+type AsyncSelect = <Option = unknown, IsMulti extends boolean = false, Group extends GroupBase<Option> = GroupBase<Option>>(props: AsyncProps<Option, IsMulti, Group> & RefAttributes<Select<Option, IsMulti, Group>>) => ReactElement;
+declare const AsyncSelect: AsyncSelect;
+export { useAsync };
+export default AsyncSelect;

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

@@ -0,0 +1,5 @@
+import { type GroupBase, type Option } from './types';
+export declare const formatGroupLabel: <Option, Group extends GroupBase<Option>>(group: Group) => string;
+export declare const getOptionLabel: (option: Option) => string;
+export declare const getOptionValue: (option: Option) => string;
+export declare const isOptionDisabled: (option: Option) => boolean;

package/dist/types-ts4.5/components/containers.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @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: JSX.IntrinsicElements['div'];
+}
+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?: JSX.IntrinsicElements['div'];
+    /**
+     * The children to be rendered.
+     */
+    children: ReactNode;
+    isDisabled: boolean;
+}
+export declare const valueContainerCSS: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>({ theme: { spacing }, isMulti, hasValue, selectProps: { controlShouldRenderValue }, }: ValueContainerProps<Option, IsMulti, Group>, unstyled: boolean) => 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-ts4.5/components/control.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @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: JSX.IntrinsicElements['div'];
+    /**
+     * Whether the select is disabled.
+     */
+    isDisabled: boolean;
+    /**
+     * Whether the select is focused.
+     */
+    isFocused: boolean;
+    /**
+     * Whether the select is expanded.
+     */
+    menuIsOpen: boolean;
+}
+export declare const css: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>({ isDisabled, isFocused, theme: { colors, borderRadius, spacing }, }: ControlProps<Option, IsMulti, Group>, unstyled: boolean) => CSSObjectWithLabel;
+declare const Control: <Option, IsMulti extends boolean, Group extends GroupBase<Option>>(props: ControlProps<Option, IsMulti, Group>) => jsx.JSX.Element;
+export default Control;