@atlaskit/select 15.7.7 → 16.0.0

package/dist/types/Select.d.ts

@@ -1,19 +1,18 @@
 /// <reference types="react" />
-import Select from 'react-select';
 export declare const SelectWithoutAnalytics: {
     new <Option = import("./types").OptionType, IsMulti extends boolean = false>(props: import("./types").SelectProps<Option, IsMulti>): {
-        components: Partial<import("react-select/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupTypeBase<Option>>>;
-        select: Select<Option, false, import("react-select").GroupTypeBase<Option>, import("react-select/src/Select").default<Option, false, import("react-select").GroupTypeBase<Option>>> | null;
+        components: Partial<import("react-select/dist/declarations/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupBase<Option>>>;
+        select: import("react-select/base").default<unknown, false, import("react-select").GroupBase<unknown>> | null;
         UNSAFE_componentWillReceiveProps(nextProps: import("./types").SelectProps<Option, IsMulti>): void;
-        cacheComponents: (components: Partial<import("react-select/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupTypeBase<Option>>>) => void;
+        cacheComponents: (components: Partial<import("react-select/dist/declarations/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupBase<Option>>>) => void;
         focus(): void;
         blur(): void;
-        onSelectRef: (ref: Select<Option, false, import("react-select").GroupTypeBase<Option>, import("react-select/src/Select").default<Option, false, import("react-select").GroupTypeBase<Option>>>) => void;
+        onSelectRef: (ref: import("react-select/base").default<unknown, false, import("react-select").GroupBase<unknown>>) => void;
         render(): JSX.Element;
         context: any;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./types").SelectProps<Option, IsMulti>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callBack?: (() => void) | undefined): void;
-        readonly props: Readonly<import("./types").SelectProps<Option, IsMulti>> & Readonly<{
+        readonly props: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>> & Readonly<{
             children?: import("react").ReactNode;
         }>;
         state: Readonly<{}>;
@@ -21,16 +20,16 @@ export declare const SelectWithoutAnalytics: {
             [key: string]: import("react").ReactInstance;
         };
         componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        shouldComponentUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): boolean;
         componentWillUnmount?(): void;
         componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<import("./types").SelectProps<Option, IsMulti>>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<import("./types").SelectProps<Option, IsMulti>>, prevState: Readonly<{}>, snapshot?: any): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, prevState: Readonly<{}>, snapshot?: any): void;
         componentWillMount?(): void;
         UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti>>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
+        componentWillReceiveProps?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
     };
     defaultProps: {
         validationState: string;
@@ -44,18 +43,18 @@ export declare const SelectWithoutAnalytics: {
 };
 declare const _default: {
     new <Option = import("./types").OptionType, IsMulti extends boolean = false>(props: import("./types").SelectProps<Option, IsMulti>): {
-        components: Partial<import("react-select/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupTypeBase<Option>>>;
-        select: Select<Option, false, import("react-select").GroupTypeBase<Option>, import("react-select/src/Select").default<Option, false, import("react-select").GroupTypeBase<Option>>> | null;
+        components: Partial<import("react-select/dist/declarations/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupBase<Option>>>;
+        select: import("react-select/base").default<unknown, false, import("react-select").GroupBase<unknown>> | null;
         UNSAFE_componentWillReceiveProps(nextProps: import("./types").SelectProps<Option, IsMulti>): void;
-        cacheComponents: (components: Partial<import("react-select/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupTypeBase<Option>>>) => void;
+        cacheComponents: (components: Partial<import("react-select/dist/declarations/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupBase<Option>>>) => void;
         focus(): void;
         blur(): void;
-        onSelectRef: (ref: Select<Option, false, import("react-select").GroupTypeBase<Option>, import("react-select/src/Select").default<Option, false, import("react-select").GroupTypeBase<Option>>>) => void;
+        onSelectRef: (ref: import("react-select/base").default<unknown, false, import("react-select").GroupBase<unknown>>) => void;
         render(): JSX.Element;
         context: any;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./types").SelectProps<Option, IsMulti>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callBack?: (() => void) | undefined): void;
-        readonly props: Readonly<import("./types").SelectProps<Option, IsMulti>> & Readonly<{
+        readonly props: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>> & Readonly<{
             children?: import("react").ReactNode;
         }>;
         state: Readonly<{}>;
@@ -63,16 +62,16 @@ declare const _default: {
             [key: string]: import("react").ReactInstance;
         };
         componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        shouldComponentUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): boolean;
         componentWillUnmount?(): void;
         componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<import("./types").SelectProps<Option, IsMulti>>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<import("./types").SelectProps<Option, IsMulti>>, prevState: Readonly<{}>, snapshot?: any): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, prevState: Readonly<{}>, snapshot?: any): void;
         componentWillMount?(): void;
         UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti>>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
+        componentWillReceiveProps?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("./types").SelectProps<Option, IsMulti> | import("./types").AsyncSelectProps<Option, IsMulti> | import("./types").CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
     };
     defaultProps: {
         validationState: string;

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

@@ -1,5 +1,6 @@
 /** @jsx jsx */
 import { jsx } from '@emotion/react';
+import { MultiValueRemoveProps } from 'react-select';
 export { ClearIndicator, DropdownIndicator, LoadingIndicator, } from './indicators';
-export declare const MultiValueRemove: (props: any) => jsx.JSX.Element;
+export declare const MultiValueRemove: (props: MultiValueRemoveProps<any>) => jsx.JSX.Element;
 export declare const IndicatorSeparator: null;

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

@@ -1,5 +1,5 @@
 import { FC } from 'react';
-import { IndicatorProps } from '../types';
-export declare const ClearIndicator: FC<IndicatorProps<any, any>>;
-export declare const DropdownIndicator: FC<IndicatorProps<any, any>>;
-export declare const LoadingIndicator: FC<any>;
+import { ClearIndicatorProps, DropdownIndicatorProps, LoadingIndicatorProps } from '../types';
+export declare const ClearIndicator: FC<ClearIndicatorProps<any>>;
+export declare const DropdownIndicator: FC<DropdownIndicatorProps<any>>;
+export declare const LoadingIndicator: FC<LoadingIndicatorProps<any>>;

package/dist/types/createSelect.d.ts

@@ -1,20 +1,20 @@
 import React, { ComponentType } from 'react';
-import Select from 'react-select';
-import { SelectProps, SelectComponentsConfig, OptionType } from './types';
+import BaseSelect from 'react-select/base';
+import { SelectProps, SelectComponentsConfig, OptionType, AsyncSelectProps, CreatableSelectProps } from './types';
 export default function createSelect(WrappedComponent: ComponentType<any>): {
     new <Option = OptionType, IsMulti extends boolean = false>(props: SelectProps<Option, IsMulti>): {
-        components: Partial<import("react-select/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupTypeBase<Option>>>;
-        select: Select<Option, false, import("react-select").GroupTypeBase<Option>, import("react-select/src/Select").default<Option, false, import("react-select").GroupTypeBase<Option>>> | null;
+        components: Partial<import("react-select/dist/declarations/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupBase<Option>>>;
+        select: BaseSelect | null;
         UNSAFE_componentWillReceiveProps(nextProps: SelectProps<Option, IsMulti>): void;
-        cacheComponents: (components: Partial<import("react-select/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupTypeBase<Option>>>) => void;
+        cacheComponents: (components: Partial<import("react-select/dist/declarations/src/components").SelectComponents<Option, IsMulti, import("react-select").GroupBase<Option>>>) => void;
         focus(): void;
         blur(): void;
-        onSelectRef: (ref: Select<Option, false, import("react-select").GroupTypeBase<Option>, import("react-select/src/Select").default<Option, false, import("react-select").GroupTypeBase<Option>>>) => void;
+        onSelectRef: (ref: BaseSelect) => void;
         render(): JSX.Element;
         context: any;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<SelectProps<Option, IsMulti>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<SelectProps<Option, IsMulti> | AsyncSelectProps<Option, IsMulti> | CreatableSelectProps<Option, IsMulti>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callBack?: (() => void) | undefined): void;
-        readonly props: Readonly<SelectProps<Option, IsMulti>> & Readonly<{
+        readonly props: Readonly<SelectProps<Option, IsMulti> | AsyncSelectProps<Option, IsMulti> | CreatableSelectProps<Option, IsMulti>> & Readonly<{
             children?: React.ReactNode;
         }>;
         state: Readonly<{}>;
@@ -22,16 +22,16 @@ export default function createSelect(WrappedComponent: ComponentType<any>): {
             [key: string]: React.ReactInstance;
         };
         componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<SelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        shouldComponentUpdate?(nextProps: Readonly<SelectProps<Option, IsMulti> | AsyncSelectProps<Option, IsMulti> | CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): boolean;
         componentWillUnmount?(): void;
         componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<SelectProps<Option, IsMulti>>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<SelectProps<Option, IsMulti>>, prevState: Readonly<{}>, snapshot?: any): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<SelectProps<Option, IsMulti> | AsyncSelectProps<Option, IsMulti> | CreatableSelectProps<Option, IsMulti>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<SelectProps<Option, IsMulti> | AsyncSelectProps<Option, IsMulti> | CreatableSelectProps<Option, IsMulti>>, prevState: Readonly<{}>, snapshot?: any): void;
         componentWillMount?(): void;
         UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<SelectProps<Option, IsMulti>>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<SelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<SelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
+        componentWillReceiveProps?(nextProps: Readonly<SelectProps<Option, IsMulti> | AsyncSelectProps<Option, IsMulti> | CreatableSelectProps<Option, IsMulti>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<SelectProps<Option, IsMulti> | AsyncSelectProps<Option, IsMulti> | CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<SelectProps<Option, IsMulti> | AsyncSelectProps<Option, IsMulti> | CreatableSelectProps<Option, IsMulti>>, nextState: Readonly<{}>, nextContext: any): void;
     };
     defaultProps: {
         validationState: string;

package/dist/types/entry-points/async-creatable-select.d.ts

@@ -0,0 +1 @@
+export { default } from '../AsyncCreatableSelect';

package/dist/types/entry-points/async-select.d.ts

@@ -0,0 +1 @@
+export { default } from '../AsyncSelect';

package/dist/types/entry-points/creatable-select.d.ts

@@ -0,0 +1 @@
+export { default } from '../CreatableSelect';

package/dist/types/entry-points/select.d.ts

@@ -0,0 +1 @@
+export { default, SelectWithoutAnalytics } from '../Select';

package/dist/types/index.d.ts

@@ -1,14 +1,20 @@
 export { components, createFilter, mergeStyles } from 'react-select';
-export { makeAsyncSelect } from 'react-select/async';
-export { makeCreatableSelect } from 'react-select/creatable';
+export { useAsync } from 'react-select/async';
+export { useCreatable } from 'react-select/creatable';
 export { CheckboxOption, RadioOption } from './components/input-options';
-export { default, SelectWithoutAnalytics } from './Select';
-export { default as AsyncSelect } from './AsyncSelect';
+export { default, SelectWithoutAnalytics } from './entry-points/select';
+export { default as AsyncSelect } from './entry-points/async-select';
+export { default as CreatableSelect } from './entry-points/creatable-select';
+export { default as AsyncCreatableSelect } from './entry-points/async-creatable-select';
 export { default as CheckboxSelect } from './CheckboxSelect';
 export { default as CountrySelect } from './CountrySelect';
 export { default as RadioSelect } from './RadioSelect';
-export { default as CreatableSelect } from './CreatableSelect';
-export { default as AsyncCreatableSelect } from './AsyncCreatableSelect';
 export { default as PopupSelect } from './PopupSelect';
-export type { PopupSelectProps } from './PopupSelect';
-export type { ActionMeta, ControlProps, FormatOptionLabelMeta, IndicatorComponentType, IndicatorProps, InputActionMeta, InputProps, MenuProps, MenuListComponentProps, OptionProps, OptionsType, OptionType, SelectComponentsConfig, SelectProps, StylesConfig, ValueContainerProps, ValueType, GroupedOptionsType, GroupType, } from './types';
+export type { PopupSelectProps, ModifierList } from './PopupSelect';
+export type { ActionMeta, ControlProps, FormatOptionLabelMeta, InputActionMeta, InputProps, MenuProps, MenuListComponentProps, OptionProps, OptionsType, OptionType, SelectComponentsConfig, SelectProps, StylesConfig, ValueContainerProps, ValueType, GroupedOptionsType, GroupType, ClearIndicatorProps, DropdownIndicatorProps, IndicatorSeparatorProps, LoadingIndicatorProps, MultiValueProps, ReactSelectProps, SingleValueProps, NoticeProps, ValidationState, GroupProps, AsyncSelectProps, } from './types';
+/**
+ * Types not exported on the public API, didn't find usages in sourcegraph
+ *
+ * CreatableSelectProps,
+ * PlaceholderProps,
+ */

package/dist/types/types.d.ts

@@ -1,7 +1,8 @@
 /// <reference types="react" />
 import { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
-import { Props as ReactSelectProps, FormatOptionLabelMeta as RSFormatOptionLabelMeta, ValueType as RSValueType, ActionMeta as RSActionMeta, GroupTypeBase as GroupType, OptionsType as RSOptionsType, SelectComponentsConfig as RSSelectComponentsConfig, IndicatorComponentType as RSIndicatorComponentType, StylesConfig as RSStylesConfig, InputActionMeta as RSInputActionMeta, IndicatorProps as RSIndicatorProps, ControlProps as RSControlProps, GroupProps as RSGroupProps, InputProps, MenuProps as RSMenuProps, MenuListComponentProps as RSMenuListComponentProps, MultiValueProps, OptionProps as ReactSelectOptionProps, PlaceholderProps as RSPlaceholderProps, SingleValueProps, ValueContainerProps as RSValueContainerProps, GroupedOptionsType } from 'react-select';
-import { AsyncProps as ReactAsyncSelectProps } from 'react-select/async';
+import { Props as ReactSelectProps, FormatOptionLabelMeta, OnChangeValue as RSValueType, ActionMeta as RSActionMeta, GroupBase as GroupType, Options as RSOptionsType, SelectComponentsConfig as RSSelectComponentsConfig, StylesConfig as RSStylesConfig, InputActionMeta, ClearIndicatorProps, DropdownIndicatorProps, IndicatorSeparatorProps, LoadingIndicatorProps, NoticeProps, ControlProps as RSControlProps, GroupProps as RSGroupProps, InputProps, MenuProps as RSMenuProps, MenuListProps as RSMenuListComponentProps, MultiValueProps, OptionProps as ReactSelectOptionProps, PlaceholderProps as RSPlaceholderProps, SingleValueProps, ValueContainerProps as RSValueContainerProps } from 'react-select';
+import { AsyncProps } from 'react-select/async';
+import { CreatableProps } from 'react-select/creatable';
 export declare type ValidationState = 'default' | 'error' | 'success';
 export interface OptionType {
     [key: string]: any;
@@ -22,24 +23,38 @@ export interface OptionProps<Option = OptionType, IsMulti extends boolean = fals
     isFocused: boolean;
     isSelected: boolean;
 }
-export interface SelectProps<OptionType, IsMulti extends boolean = false> extends ReactSelectProps<OptionType, IsMulti>, WithAnalyticsEventsProps {
+interface CustomSelectProps extends WithAnalyticsEventsProps {
+    /** This prop affects the height of the select control. Compact is gridSize() * 4, default is gridSize * 5  */
     spacing?: 'compact' | 'default';
+    /** @deprecated Use isInvalid instead. The state of validation if used in a form.  */
     validationState?: ValidationState;
+    /** This prop affects the backgroundColor and border of the Select field. 'subtle' makes these transparent while 'none' removes them completely */
     appearance?: 'default' | 'subtle' | 'none';
+    /** This prop indicates if the component is in an error state */
     isInvalid?: boolean;
+    /** Prop for testing */
+    testId?: string;
+}
+export interface SelectProps<Option, IsMulti extends boolean = false> extends ReactSelectProps<Option, IsMulti>, CustomSelectProps {
+}
+export interface AsyncSelectProps<Option, IsMulti extends boolean = false> extends AsyncProps<Option, IsMulti, GroupType<Option>>, CustomSelectProps {
+}
+export interface CreatableSelectProps<Option, IsMulti extends boolean = false> extends CreatableProps<Option, IsMulti, GroupType<Option>>, CustomSelectProps {
 }
 export declare type ActionMeta<Option = OptionType> = RSActionMeta<Option>;
-export declare type InputActionMeta = RSInputActionMeta;
-export declare type ControlProps<OptionType, IsMulti extends boolean = false> = RSControlProps<OptionType, IsMulti>;
-export declare type FormatOptionLabelMeta<OptionType, IsMulti extends boolean = false> = RSFormatOptionLabelMeta<OptionType, IsMulti>;
-export declare type IndicatorProps<OptionType, IsMulti extends boolean = false> = RSIndicatorProps<OptionType, IsMulti>;
-export declare type IndicatorComponentType<OptionType, IsMulti extends boolean = false> = RSIndicatorComponentType<OptionType, IsMulti>;
-export declare type ValueType<OptionType, IsMulti extends boolean = false> = RSValueType<OptionType, IsMulti>;
+export declare type ControlProps<Option, IsMulti extends boolean = false> = RSControlProps<Option, IsMulti>;
+export declare type ValueType<Option, IsMulti extends boolean = false> = RSValueType<Option, IsMulti>;
 export declare type StylesConfig<Option = OptionType, IsMulti extends boolean = false> = RSStylesConfig<Option, IsMulti>;
-export declare type SelectComponentsConfig<OptionType, IsMulti extends boolean = false> = RSSelectComponentsConfig<OptionType, IsMulti>;
-export declare type GroupProps<OptionType, IsMulti extends boolean = false> = RSGroupProps<OptionType, IsMulti>;
-export declare type MenuProps<OptionType, IsMulti extends boolean = false> = RSMenuProps<OptionType, IsMulti>;
-export declare type MenuListComponentProps<OptionType, IsMulti extends boolean = false> = RSMenuListComponentProps<OptionType, IsMulti>;
-export declare type PlaceholderProps<OptionType, IsMulti extends boolean = false> = RSPlaceholderProps<OptionType, IsMulti>;
-export declare type ValueContainerProps<OptionType, IsMulti extends boolean = false> = RSValueContainerProps<OptionType, IsMulti>;
-export type { GroupType, InputProps, MultiValueProps, ReactAsyncSelectProps, ReactSelectProps, SingleValueProps, GroupedOptionsType, };
+export declare type SelectComponentsConfig<Option, IsMulti extends boolean = false> = RSSelectComponentsConfig<Option, IsMulti, GroupType<Option>>;
+export declare type GroupProps<Option, IsMulti extends boolean = false> = RSGroupProps<Option, IsMulti>;
+export declare type MenuProps<Option, IsMulti extends boolean = false> = RSMenuProps<Option, IsMulti>;
+export declare type MenuListComponentProps<Option, IsMulti extends boolean = false> = RSMenuListComponentProps<Option, IsMulti>;
+export declare type PlaceholderProps<Option, IsMulti extends boolean = false> = RSPlaceholderProps<Option, IsMulti>;
+export declare type ValueContainerProps<Option, IsMulti extends boolean = false> = RSValueContainerProps<Option, IsMulti>;
+export declare type GroupedOptionsType<Option> = ReadonlyArray<GroupType<Option>>;
+export type { FormatOptionLabelMeta, InputActionMeta, GroupType, InputProps, MultiValueProps, ReactSelectProps, SingleValueProps, ClearIndicatorProps, DropdownIndicatorProps, IndicatorSeparatorProps, LoadingIndicatorProps, NoticeProps, };
+declare module 'react-select/dist/declarations/src/Select' {
+    interface Props<Option, IsMulti extends boolean, Group extends GroupType<Option>> {
+        [key: string]: any;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/select",
-  "version": "15.7.7",
+  "version": "16.0.0",
   "description": "Select allows users to make a single selection or multiple selections from a list of options.",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
@@ -17,31 +17,36 @@
   "atlassian": {
     "disableProductCI": true,
     "team": "Design System Team",
-    "deprecatedAutoEntryPoints": true,
     "releaseModel": "scheduled",
     "website": {
       "name": "Select",
       "category": "Components"
     }
   },
+  "af:exports": {
+    "./AsyncSelect": "./src/entry-points/async-select.tsx",
+    "./Select": "./src/entry-points/select.tsx",
+    "./AsyncCreatableSelect": "./src/entry-points/async-creatable-select.tsx",
+    "./CreatableSelect": "./src/entry-points/creatable-select.tsx",
+    ".": "./src/index.tsx"
+  },
   "dependencies": {
     "@atlaskit/analytics-next": "^8.2.0",
     "@atlaskit/icon": "^21.11.0",
-    "@atlaskit/spinner": "^15.2.0",
+    "@atlaskit/spinner": "^15.3.0",
     "@atlaskit/theme": "^12.2.0",
     "@atlaskit/tokens": "^0.11.0",
     "@atlaskit/visually-hidden": "^1.1.0",
     "@babel/runtime": "^7.0.0",
     "@emotion/react": "^11.7.1",
     "@popperjs/core": "^2.9.1",
-    "@types/react-select": "^4.0.18",
     "bind-event-listener": "^2.1.1",
     "memoize-one": "^6.0.0",
     "react-fast-compare": "^3.2.0",
     "react-focus-lock": "^2.5.2",
     "react-node-resolver": "^1.0.1",
     "react-popper": "^2.2.3",
-    "react-select": "^4.3.1",
+    "react-select": "^5.4.0",
     "react-uid": "^2.2.0",
     "shallow-equal": "^1.0.0"
   },
@@ -50,11 +55,11 @@
     "react-dom": "^16.8.0"
   },
   "devDependencies": {
-    "@atlaskit/button": "^16.4.0",
+    "@atlaskit/button": "^16.5.0",
     "@atlaskit/checkbox": "^12.4.0",
     "@atlaskit/docs": "*",
     "@atlaskit/drawer": "^7.4.0",
-    "@atlaskit/form": "^8.7.0",
+    "@atlaskit/form": "^8.8.0",
     "@atlaskit/logo": "^13.10.0",
     "@atlaskit/modal-dialog": "^12.4.0",
     "@atlaskit/radio": "^5.4.0",