@sprinklrjs/spaceweb 12.14.4 → 12.33.2

package/baseui/select/default-props.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+/*
+Copyright (c) Uber Technologies, Inc.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+*/
+var default_filter_options_1 = (0, tslib_1.__importDefault)(require("./utils/default-filter-options"));
+var constants_1 = require("./constants");
+var defaultProps = {
+    // @ts-ignore
+    'aria-label': null,
+    // @ts-ignore
+    'aria-describedby': null,
+    // @ts-ignore
+    'aria-errormessage': null,
+    // @ts-ignore
+    'aria-labelledby': null,
+    autoFocus: false,
+    backspaceRemoves: true,
+    clearable: true,
+    closeOnSelect: true,
+    creatable: false,
+    deleteRemoves: true,
+    disabled: false,
+    error: false,
+    positive: false,
+    escapeClearsValue: true,
+    filterOptions: default_filter_options_1.default,
+    filterOutSelected: true,
+    // @ts-ignore
+    getOptionLabel: null,
+    // @ts-ignore
+    getValueLabel: null,
+    ignoreCase: true,
+    isLoading: false,
+    labelKey: 'label',
+    maxDropdownHeight: '40vh',
+    multi: false,
+    onBlur: function () { },
+    onBlurResetsInput: true,
+    onChange: function () { },
+    onFocus: function () { },
+    onInputChange: function () { },
+    onCloseResetsInput: true,
+    onSelectResetsInput: true,
+    // @ts-ignore
+    onOpen: null,
+    // @ts-ignore
+    onClose: null,
+    openOnClick: true,
+    startOpen: false,
+    // @ts-ignore
+    options: [],
+    overrides: {},
+    required: false,
+    searchable: true,
+    size: constants_1.SIZE.default,
+    type: constants_1.TYPE.select,
+    // @ts-ignore
+    value: [],
+    valueKey: 'id',
+};
+exports.default = defaultProps;

package/baseui/select/dropdown.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import type { DropdownProps } from './types';
+import type { SyntheticEvent } from 'react';
+export default class SelectDropdown extends React.Component<DropdownProps> {
+    getSharedProps(): {
+        $error: boolean;
+        $isLoading: boolean;
+        $multi: boolean;
+        $required: boolean;
+        $searchable: boolean;
+        $size: "default" | "large" | "compact" | "mini";
+        $type: "search" | "select";
+        $width: number | null | undefined;
+    };
+    getItemLabel: (option: {
+        [x: string]: any;
+    }) => import("react/jsx-runtime").JSX.Element;
+    onMouseDown: (e: SyntheticEvent) => void;
+    getHighlightedIndex: () => number;
+    render(): import("react/jsx-runtime").JSX.Element;
+}

package/baseui/select/dropdown.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var jsx_runtime_1 = require("react/jsx-runtime");
+/*
+Copyright (c) Uber Technologies, Inc.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+*/
+var React = (0, tslib_1.__importStar)(require("react"));
+var styled_components_1 = require("./styled-components");
+var overrides_1 = require("../helpers/overrides");
+function groupOptions(options) {
+    return options.reduce(function (groups, option) {
+        if (option.__optgroup) {
+            if (!groups[option.__optgroup]) {
+                // @ts-expect-error todo(flow->ts): modifying what is declared as readonly array
+                groups[option.__optgroup] = [];
+            }
+            groups[option.__optgroup].push(option);
+        }
+        else {
+            groups.__ungrouped.push(option);
+        }
+        return groups;
+    }, { __ungrouped: [] });
+}
+var SelectDropdown = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(SelectDropdown, _super);
+    function SelectDropdown() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        _this.getItemLabel = function (option) {
+            var _a = _this.props, getOptionLabel = _a.getOptionLabel, _b = _a.overrides, overrides = _b === void 0 ? {} : _b, value = _a.value, valueKey = _a.valueKey, selectAllChecked = _a.selectAllChecked;
+            var _c = (0, tslib_1.__read)((0, overrides_1.getOverrides)(overrides.OptionContent, styled_components_1.StyledOptionContent), 2), OptionContent = _c[0], optionContentProps = _c[1];
+            var $selected;
+            if (Array.isArray(value)) {
+                $selected = !!value.find(function (selected) { return selected && selected[valueKey] === option[valueKey]; });
+            }
+            else {
+                // @ts-ignore
+                $selected = value[valueKey] === option[valueKey];
+            }
+            var optionSharedProps = {
+                $selected: $selected,
+                $disabled: option.disabled,
+                $isHighlighted: option.isHighlighted,
+            };
+            return ((0, jsx_runtime_1.jsx)(OptionContent, (0, tslib_1.__assign)({ "aria-readonly": option.disabled, "aria-selected": $selected }, _this.getSharedProps(), optionSharedProps, optionContentProps, { children: getOptionLabel({ option: option, optionState: optionSharedProps }) }), option[valueKey]));
+        };
+        _this.onMouseDown = function (e) {
+            e.nativeEvent.stopImmediatePropagation();
+        };
+        _this.getHighlightedIndex = function () {
+            var _a = _this.props, value = _a.value, options = _a.options, valueKey = _a.valueKey;
+            // Highlight only first value as menu supports only a single highlight index
+            var firstValue = {};
+            if (Array.isArray(value) && value.length > 0) {
+                firstValue = value[0];
+            }
+            else if (!(value instanceof Array)) {
+                firstValue = value;
+            }
+            if (Object.keys(firstValue).length > 0) {
+                var a = options.findIndex(function (option) { return option && option[valueKey] === firstValue[valueKey]; });
+                return a === -1 ? 0 : a;
+            }
+            return 0;
+        };
+        return _this;
+    }
+    SelectDropdown.prototype.getSharedProps = function () {
+        var _a = this.props, error = _a.error, isLoading = _a.isLoading, multi = _a.multi, required = _a.required, size = _a.size, searchable = _a.searchable, type = _a.type, width = _a.width;
+        return {
+            $error: error,
+            $isLoading: isLoading,
+            $multi: multi,
+            $required: required,
+            $searchable: searchable,
+            $size: size,
+            $type: type,
+            $width: width,
+        };
+    };
+    SelectDropdown.prototype.render = function () {
+        var _this = this;
+        // TODO(#185) Add no-results and loading states to menu
+        var _a = this.props, maxDropdownHeight = _a.maxDropdownHeight, multi = _a.multi, noResultsMsg = _a.noResultsMsg, onItemSelect = _a.onItemSelect, _b = _a.options, options = _b === void 0 ? [] : _b, _c = _a.overrides, overrides = _c === void 0 ? {} : _c, size = _a.size, selectAllChecked = _a.selectAllChecked;
+        var _d = (0, tslib_1.__read)((0, overrides_1.getOverrides)(overrides.DropdownContainer, styled_components_1.StyledDropdownContainer), 2), DropdownContainer = _d[0], dropdownContainerProps = _d[1];
+        var _e = (0, tslib_1.__read)((0, overrides_1.getOverrides)(overrides.DropdownListItem, styled_components_1.StyledDropdownListItem), 2), ListItem = _e[0], listItemProps = _e[1];
+        var _f = (0, tslib_1.__read)((0, overrides_1.getOverrides)(overrides.StatefulMenu, function () { return null; }), 2), OverriddenStatefulMenu = _f[0], _g = _f[1], _h = _g.overrides, statefulMenuOverrides = _h === void 0 ? {} : _h, restStatefulMenuProps = (0, tslib_1.__rest)(_g, ["overrides"]);
+        var highlightedIndex = this.getHighlightedIndex();
+        var groupedOptions = groupOptions(options);
+        return ((0, jsx_runtime_1.jsx)(DropdownContainer, (0, tslib_1.__assign)({ "data-no-focus-lock": true, ref: this.props.innerRef }, this.getSharedProps(), dropdownContainerProps, { children: (0, jsx_runtime_1.jsx)(OverriddenStatefulMenu, (0, tslib_1.__assign)({ noResultsMsg: noResultsMsg, 
+                // @ts-ignore
+                onActiveDescendantChange: function (id) {
+                    if (_this.props.onActiveDescendantChange) {
+                        _this.props.onActiveDescendantChange(id);
+                    }
+                }, onItemSelect: onItemSelect, items: groupedOptions, size: size, initialState: {
+                    isFocused: true,
+                    highlightedIndex: highlightedIndex,
+                }, typeAhead: false, keyboardControlNode: this.props.keyboardControlNode, forceHighlight: true, selectAllSelected: selectAllChecked, overrides: (0, overrides_1.mergeOverrides)({
+                    List: {
+                        component: styled_components_1.StyledDropdown,
+                        style: function (p) { return ({
+                            maxHeight: p.$maxHeight || null,
+                        }); },
+                        props: {
+                            id: this.props.id ? this.props.id : null,
+                            $maxHeight: maxDropdownHeight,
+                            'aria-multiselectable': multi,
+                        },
+                    },
+                    Option: {
+                        props: {
+                            getItemLabel: this.getItemLabel,
+                            // figure out why the onClick handler is not
+                            // triggered without this temporary fix
+                            onMouseDown: this.onMouseDown,
+                            overrides: {
+                                ListItem: {
+                                    component: ListItem,
+                                    props: (0, tslib_1.__assign)((0, tslib_1.__assign)({}, listItemProps), { role: 'option' }),
+                                    // slightly hacky way to handle the list item style overrides
+                                    // since the menu component doesn't provide a top level overrides for it
+                                    style: listItemProps.$style,
+                                },
+                            },
+                            renderHrefAsAnchor: false,
+                        },
+                    },
+                }, (0, tslib_1.__assign)({ List: overrides.Dropdown || {}, Option: overrides.DropdownOption || {} }, statefulMenuOverrides)) }, restStatefulMenuProps), void 0) }), void 0));
+    };
+    return SelectDropdown;
+}(React.Component));
+exports.default = SelectDropdown;

package/baseui/select/index.d.ts

@@ -0,0 +1,19 @@
+import type { Optgroups, Options } from './types';
+export { default as Select } from './select';
+export { default as SingleSelect } from './single-select';
+export { default as MultiSelect } from './multi-select';
+export { default as SingleValue } from './value';
+export { default as MultiValue } from './multi-value';
+export { default as AutosizeInput } from './autosize-input';
+export { default as SelectDropdown } from './dropdown';
+export { default as StatefulSelect } from './stateful-select';
+export { default as StatefulSelectContainer } from './stateful-select-container';
+export { StyledRoot, StyledControlContainer, StyledValueContainer, StyledPlaceholder, StyledSingleValue, StyledInputContainer, StyledInput, StyledInputSizer, StyledIconsContainer, StyledSelectArrow, StyledClearIcon, StyledSearchIconContainer, StyledDropdownContainer, StyledDropdown, StyledDropdownListItem, StyledOptionContent, } from './styled-components';
+export { default as filterOptions } from './utils/default-filter-options';
+export { SIZE, TYPE, STATE_CHANGE_TYPE } from './constants';
+export * from './types';
+export type { SelectLocale } from './locale';
+/** @deprecated use Optgroups instead. To be removed in future versions.*/
+export declare type OptgroupsT = Optgroups;
+/** @deprecated use Options instead. To be removed in future versions.*/
+export declare type OptionsT = Options;

package/baseui/select/index.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATE_CHANGE_TYPE = exports.TYPE = exports.SIZE = exports.filterOptions = exports.StyledOptionContent = exports.StyledDropdownListItem = exports.StyledDropdown = exports.StyledDropdownContainer = exports.StyledSearchIconContainer = exports.StyledClearIcon = exports.StyledSelectArrow = exports.StyledIconsContainer = exports.StyledInputSizer = exports.StyledInput = exports.StyledInputContainer = exports.StyledSingleValue = exports.StyledPlaceholder = exports.StyledValueContainer = exports.StyledControlContainer = exports.StyledRoot = exports.StatefulSelectContainer = exports.StatefulSelect = exports.SelectDropdown = exports.AutosizeInput = exports.MultiValue = exports.SingleValue = exports.MultiSelect = exports.SingleSelect = exports.Select = void 0;
+var tslib_1 = require("tslib");
+var select_1 = require("./select");
+Object.defineProperty(exports, "Select", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(select_1).default; } });
+var single_select_1 = require("./single-select");
+Object.defineProperty(exports, "SingleSelect", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(single_select_1).default; } });
+var multi_select_1 = require("./multi-select");
+Object.defineProperty(exports, "MultiSelect", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(multi_select_1).default; } });
+var value_1 = require("./value");
+Object.defineProperty(exports, "SingleValue", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(value_1).default; } });
+var multi_value_1 = require("./multi-value");
+Object.defineProperty(exports, "MultiValue", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(multi_value_1).default; } });
+var autosize_input_1 = require("./autosize-input");
+Object.defineProperty(exports, "AutosizeInput", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(autosize_input_1).default; } });
+var dropdown_1 = require("./dropdown");
+Object.defineProperty(exports, "SelectDropdown", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(dropdown_1).default; } });
+var stateful_select_1 = require("./stateful-select");
+Object.defineProperty(exports, "StatefulSelect", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(stateful_select_1).default; } });
+var stateful_select_container_1 = require("./stateful-select-container");
+Object.defineProperty(exports, "StatefulSelectContainer", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(stateful_select_container_1).default; } });
+// Styled elements
+var styled_components_1 = require("./styled-components");
+Object.defineProperty(exports, "StyledRoot", { enumerable: true, get: function () { return styled_components_1.StyledRoot; } });
+Object.defineProperty(exports, "StyledControlContainer", { enumerable: true, get: function () { return styled_components_1.StyledControlContainer; } });
+Object.defineProperty(exports, "StyledValueContainer", { enumerable: true, get: function () { return styled_components_1.StyledValueContainer; } });
+Object.defineProperty(exports, "StyledPlaceholder", { enumerable: true, get: function () { return styled_components_1.StyledPlaceholder; } });
+Object.defineProperty(exports, "StyledSingleValue", { enumerable: true, get: function () { return styled_components_1.StyledSingleValue; } });
+Object.defineProperty(exports, "StyledInputContainer", { enumerable: true, get: function () { return styled_components_1.StyledInputContainer; } });
+Object.defineProperty(exports, "StyledInput", { enumerable: true, get: function () { return styled_components_1.StyledInput; } });
+Object.defineProperty(exports, "StyledInputSizer", { enumerable: true, get: function () { return styled_components_1.StyledInputSizer; } });
+Object.defineProperty(exports, "StyledIconsContainer", { enumerable: true, get: function () { return styled_components_1.StyledIconsContainer; } });
+Object.defineProperty(exports, "StyledSelectArrow", { enumerable: true, get: function () { return styled_components_1.StyledSelectArrow; } });
+Object.defineProperty(exports, "StyledClearIcon", { enumerable: true, get: function () { return styled_components_1.StyledClearIcon; } });
+Object.defineProperty(exports, "StyledSearchIconContainer", { enumerable: true, get: function () { return styled_components_1.StyledSearchIconContainer; } });
+Object.defineProperty(exports, "StyledDropdownContainer", { enumerable: true, get: function () { return styled_components_1.StyledDropdownContainer; } });
+Object.defineProperty(exports, "StyledDropdown", { enumerable: true, get: function () { return styled_components_1.StyledDropdown; } });
+Object.defineProperty(exports, "StyledDropdownListItem", { enumerable: true, get: function () { return styled_components_1.StyledDropdownListItem; } });
+Object.defineProperty(exports, "StyledOptionContent", { enumerable: true, get: function () { return styled_components_1.StyledOptionContent; } });
+var default_filter_options_1 = require("./utils/default-filter-options");
+Object.defineProperty(exports, "filterOptions", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(default_filter_options_1).default; } });
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "SIZE", { enumerable: true, get: function () { return constants_1.SIZE; } });
+Object.defineProperty(exports, "TYPE", { enumerable: true, get: function () { return constants_1.TYPE; } });
+Object.defineProperty(exports, "STATE_CHANGE_TYPE", { enumerable: true, get: function () { return constants_1.STATE_CHANGE_TYPE; } });
+(0, tslib_1.__exportStar)(require("./types"), exports);

package/baseui/select/locale.d.ts

@@ -0,0 +1,8 @@
+export declare type SelectLocale = {
+    noResultsMsg: string;
+    placeholder: string;
+    create: string;
+    selectAllLabel: string;
+};
+declare const locale: SelectLocale;
+export default locale;

package/baseui/select/locale.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var locale = {
+    // Remove noResultsMsg prop in the next major version
+    noResultsMsg: 'No results found',
+    placeholder: 'Select...',
+    create: 'Create',
+    selectAllLabel: 'Select All',
+};
+exports.default = locale;

package/baseui/select/multi-select.d.ts

@@ -0,0 +1,3 @@
+import type { SelectProps } from './types';
+declare function MultiSelect(props: Partial<SelectProps>): import("react/jsx-runtime").JSX.Element;
+export default MultiSelect;

package/baseui/select/multi-select.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var jsx_runtime_1 = require("react/jsx-runtime");
+var select_component_1 = (0, tslib_1.__importDefault)(require("./select-component"));
+var multi_value_1 = (0, tslib_1.__importDefault)(require("./multi-value"));
+function MultiSelect(props) {
+    return (0, jsx_runtime_1.jsx)(select_component_1.default, (0, tslib_1.__assign)({}, props, { multi: true, valueComponent: multi_value_1.default }), void 0);
+}
+exports.default = MultiSelect;

package/baseui/select/multi-value.d.ts

@@ -0,0 +1 @@
+export default function MultiValue(props: any): import("react/jsx-runtime").JSX.Element;

package/baseui/select/multi-value.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var jsx_runtime_1 = require("react/jsx-runtime");
+var overrides_1 = require("../helpers/overrides");
+function MultiValue(props) {
+    var _a = props.overrides, overrides = _a === void 0 ? {} : _a, removeValue = props.removeValue, restProps = (0, tslib_1.__rest)(props, ["overrides", "removeValue"]);
+    // todo(v11): remove the MultiValue override in favor of Tag
+    var _b = (0, tslib_1.__read)((0, overrides_1.getOverrides)(overrides.Tag || overrides.MultiValue, function () { return null; }), 2), MultiValue = _b[0], tagProps = _b[1];
+    return ((0, jsx_runtime_1.jsx)(MultiValue, (0, tslib_1.__assign)({ overrides: {}, onActionClick: removeValue }, restProps, tagProps, { children: props.children }), void 0));
+}
+exports.default = MultiValue;

package/baseui/select/select-component.d.ts

@@ -0,0 +1,179 @@
+import * as React from 'react';
+import type { Locale } from '../locale';
+import type { SelectProps, SelectState, Value, Option, ChangeAction } from './types';
+import type { SyntheticEvent, ChangeEvent } from 'react';
+import { Options } from './types';
+export declare function isInteractive(rootTarget: EventTarget | null, rootElement: Element): boolean;
+declare class Select extends React.Component<SelectProps, SelectState> {
+    static defaultProps: {
+        'aria-label': null;
+        'aria-describedby': null;
+        'aria-errormessage': null;
+        'aria-labelledby': null;
+        autoFocus: boolean;
+        backspaceRemoves: boolean;
+        clearable: boolean;
+        closeOnSelect: boolean;
+        creatable: boolean;
+        deleteRemoves: boolean;
+        disabled: boolean;
+        error: boolean;
+        positive: boolean;
+        escapeClearsValue: boolean;
+        filterOptions: (options: Value, filterValue: string, excludeOptions?: Value | null | undefined, newProps?: Partial<{
+            filterOption: ((option: Readonly<{
+                [x: string]: any;
+                id?: string | number | undefined;
+                label?: React.ReactNode;
+                disabled?: boolean | undefined;
+                clearableValue?: boolean | undefined;
+                isCreatable?: boolean | undefined;
+                __optgroup?: string | undefined;
+                searchTags?: string[] | undefined;
+            }>, filterValue: string) => boolean) | null | undefined;
+            ignoreCase: boolean;
+            labelKey: string;
+            matchPos: "start" | "any";
+            matchProp: "label" | "value" | "any";
+            trimFilter: boolean;
+            valueKey: string;
+        }> | null | undefined) => Readonly<{
+            [x: string]: any;
+            id?: string | number | undefined;
+            label?: React.ReactNode;
+            disabled?: boolean | undefined;
+            clearableValue?: boolean | undefined;
+            isCreatable?: boolean | undefined;
+            __optgroup?: string | undefined;
+            searchTags?: string[] | undefined;
+        }>[];
+        filterOutSelected: boolean;
+        getOptionLabel: null;
+        getValueLabel: null;
+        ignoreCase: boolean;
+        isLoading: boolean;
+        labelKey: string;
+        maxDropdownHeight: string;
+        multi: boolean;
+        onBlur: () => void;
+        onBlurResetsInput: boolean;
+        onChange: () => void;
+        onFocus: () => void;
+        onInputChange: () => void;
+        onCloseResetsInput: boolean;
+        onSelectResetsInput: boolean;
+        onOpen: null;
+        onClose: null;
+        openOnClick: boolean;
+        startOpen: boolean;
+        options: never[];
+        overrides: {};
+        required: boolean;
+        searchable: boolean;
+        size: "default";
+        type: "select";
+        value: never[];
+        valueKey: string;
+    };
+    anchor: React.RefObject<HTMLElement>;
+    dropdown: React.RefObject<HTMLElement>;
+    input?: HTMLInputElement;
+    dragging: boolean;
+    focusAfterClear: boolean;
+    openAfterFocus: boolean;
+    justSelected: boolean;
+    options: Value;
+    state: {
+        activeDescendant: null;
+        inputValue: string;
+        isFocused: boolean;
+        isOpen: boolean;
+        isPseudoFocused: boolean;
+    };
+    isItMounted: boolean;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: SelectProps, prevState: SelectState): void;
+    componentWillUnmount(): void;
+    focus(): void;
+    handleDropdownOpen(nextOpenState: boolean): void;
+    handleSetInputValue(newInputValue: string): void;
+    handleSetInputFocus(): void;
+    handleSetInputBlur(): void;
+    handleTouchOutside: (event: TouchEvent) => void;
+    handleTouchMove: () => boolean;
+    handleTouchStart: () => boolean;
+    handleTouchEnd: (event: TouchEvent) => void;
+    handleClick: (event: MouseEvent | TouchEvent) => void;
+    closeMenu(): void;
+    handleInputFocus: (event: SyntheticEvent<HTMLElement>) => void;
+    handleBlur: (event: React.FocusEvent | MouseEvent) => void;
+    handleClickOutside: (event: MouseEvent) => void;
+    handleInputChange: (event: ChangeEvent<HTMLInputElement>) => void;
+    handleKeyDown: (event: KeyboardEvent) => void;
+    getOptionLabel: (locale: Locale, { option, }: {
+        option: Option;
+        optionState: {
+            $selected: boolean;
+            $disabled: boolean;
+            $isHighlighted: boolean;
+        };
+    }) => React.ReactNode;
+    getValueLabel: ({ option }: {
+        option: Option;
+    }) => React.ReactNode;
+    /**
+     * Extends the value into an array from the given options
+     */
+    getValueArray(value: Value): Array<Option>;
+    setValue(value: Value, option: Option | undefined | null, type: ChangeAction): void;
+    handleActiveDescendantChange: (id?: string | undefined) => void;
+    handleInputRef: (input: HTMLInputElement) => void;
+    selectValue: ({ item }: {
+        item: Option;
+    }) => void;
+    addValue: (item: Option) => void;
+    backspaceValue: () => void;
+    popValue: () => Readonly<{
+        [x: string]: any;
+        id?: string | number | undefined;
+        label?: React.ReactNode;
+        disabled?: boolean | undefined;
+        clearableValue?: boolean | undefined;
+        isCreatable?: boolean | undefined;
+        __optgroup?: string | undefined;
+        searchTags?: string[] | undefined;
+    }> | undefined;
+    removeValue: (item: Option | Option[]) => void;
+    clearValue: (event: KeyboardEvent | MouseEvent | TouchEvent) => void;
+    shouldShowPlaceholder: () => boolean;
+    shouldShowValue: () => boolean;
+    renderLoading(): import("react/jsx-runtime").JSX.Element | undefined;
+    isSelectAllChecked: (valueArray: Option[] | Value, filteredOptions: Option[] | Value) => boolean;
+    getMemoizedSelectAllChecked: (valueArray: Option[] | Value, filteredOptions: Option[] | Value) => boolean;
+    renderValue(valueArray: Value): React.ReactNode;
+    renderInput(listboxId: string): import("react/jsx-runtime").JSX.Element;
+    renderClear(): import("react/jsx-runtime").JSX.Element | null;
+    renderArrow(): import("react/jsx-runtime").JSX.Element | null;
+    renderSearch(): import("react/jsx-runtime").JSX.Element | null;
+    getMemoizedNormalizedOptions: (options: Options) => Value;
+    filterOptions(excludeOptions?: Value | null, filterValue?: string, options?: Options): Value;
+    getSharedProps(): {
+        $clearable: boolean | undefined;
+        $creatable: boolean | undefined;
+        $disabled: boolean | undefined;
+        $error: boolean | undefined;
+        $positive: boolean | undefined;
+        $isFocused: boolean;
+        $isLoading: boolean | undefined;
+        $isOpen: boolean;
+        $isPseudoFocused: boolean;
+        $multi: boolean | undefined;
+        $required: boolean | undefined;
+        $searchable: boolean | undefined;
+        $size: "default" | "large" | "compact" | "mini";
+        $type: "search" | "select" | undefined;
+        $isEmpty: boolean;
+    };
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export default Select;