@via-profit/ui-kit 0.1.0-rc.9 → 0.1.0-rc.91

package/Accordion/AccordionActions.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export type AccordionActionsProps = React.HTMLAttributes<HTMLDivElement> & {
+    readonly noPadding?: boolean;
+};
+declare const _default: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    readonly noPadding?: boolean | undefined;
+} & React.RefAttributes<HTMLDivElement>>;
+export default _default;

package/Accordion/AccordionActions.js

@@ -0,0 +1,31 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const styled_1 = __importDefault(require("@emotion/styled"));
+const StyledActions = styled_1.default.div `
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  padding: ${({ $noPadding }) => ($noPadding ? '0' : '1rem 0')};
+  border-bottom-left-radius: inherit;
+  border-bottom-right-radius: inherit;
+`;
+const AccordionActions = (props, ref) => {
+    const { children, noPadding } = props, nativeProps = __rest(props, ["children", "noPadding"]);
+    return (react_1.default.createElement(StyledActions, Object.assign({}, nativeProps, { "$noPadding": Boolean(noPadding), ref: ref }), children));
+};
+exports.default = react_1.default.forwardRef(AccordionActions);

package/Accordion/AccordionContainer.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export type AccordionContainerProps = React.HTMLAttributes<HTMLDivElement> & {
+    readonly inline?: boolean;
+};
+declare const _default: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    readonly inline?: boolean | undefined;
+} & React.RefAttributes<HTMLDivElement>>;
+export default _default;

package/Accordion/AccordionContainer.js

@@ -0,0 +1,61 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const styled_1 = __importDefault(require("@emotion/styled"));
+const StyledAccordionContainer = styled_1.default.div `
+  display: ${({ $inline }) => ($inline ? 'inline-flex' : 'flex')};
+  box-sizing: border-box;
+  flex-direction: column;
+  background: ${({ theme }) => theme.color.surface.toString()};
+  color: ${({ theme }) => theme.color.textPrimary.toString()};
+  border-radius: ${({ theme }) => theme.shape.radiusFactor}em;
+  font-size: 1em;
+  position: relative;
+  margin-top: 1px;
+  box-shadow:
+    ${({ theme }) => theme.isDark
+    ? theme.color.backgroundSecondary.lighten(80).alpha(0.2).toString()
+    : theme.color.backgroundSecondary.lighten(50).alpha(0.2).toString()}
+      0px 2px 1px -1px,
+    ${({ theme }) => theme.isDark
+    ? theme.color.backgroundSecondary.lighten(80).alpha(0.14).toString()
+    : theme.color.backgroundSecondary.lighten(50).alpha(0.14).toString()}
+      0px 1px 1px 0px,
+    ${({ theme }) => theme.isDark
+    ? theme.color.backgroundSecondary.lighten(80).alpha(0.12).toString()
+    : theme.color.backgroundSecondary.lighten(50).alpha(0.12).toString()}
+      0px 1px 3px 0px;
+  margin-top: 1px;
+
+  &:has(+ div[class*='StyledAccordionContainer']) {
+    border-radius: ${({ theme }) => theme.shape.radiusFactor}em
+      ${({ theme }) => theme.shape.radiusFactor}em 0 0;
+  }
+
+  & + div[class*='StyledAccordionContainer'] {
+    border-radius: 0 0 0 0;
+  }
+  &:not(:has(+ div[class*='StyledAccordionContainer'])) {
+    border-radius: 0 0 ${({ theme }) => theme.shape.radiusFactor}em
+      ${({ theme }) => theme.shape.radiusFactor}em;
+  }
+`;
+const AccordionContainer = (props, ref) => {
+    const { inline, children } = props, nativeProps = __rest(props, ["inline", "children"]);
+    return (react_1.default.createElement(StyledAccordionContainer, Object.assign({ "$inline": inline }, nativeProps, { ref: ref }), children));
+};
+exports.default = react_1.default.forwardRef(AccordionContainer);

package/Accordion/AccordionContent.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export type AccordionContentProps = React.HTMLAttributes<HTMLDivElement> & {
+    readonly noPadding?: boolean;
+    readonly isOpen: boolean;
+};
+declare const _default: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    readonly noPadding?: boolean | undefined;
+    readonly isOpen: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+export default _default;

package/Accordion/AccordionContent.js

@@ -0,0 +1,35 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const styled_1 = __importDefault(require("@emotion/styled"));
+const StyledAccordionContent = styled_1.default.div `
+  flex: 1;
+  overflow: auto;
+  transition: all 0.3s ease-out;
+  max-height: ${({ $isOpen }) => (!$isOpen ? '0px' : '90vh')};
+  box-sizing: content-box;
+  overflow: hidden;
+`;
+const Wrapper = styled_1.default.div `
+  padding: ${({ $noPadding }) => ($noPadding ? '0' : '1rem')};
+`;
+const AccordionContent = (props, ref) => {
+    const { children, noPadding, isOpen } = props, nativeProps = __rest(props, ["children", "noPadding", "isOpen"]);
+    return (react_1.default.createElement(StyledAccordionContent, Object.assign({ "$isOpen": isOpen }, nativeProps, { ref: ref }),
+        react_1.default.createElement(Wrapper, { "$noPadding": Boolean(noPadding) }, children)));
+};
+exports.default = react_1.default.forwardRef(AccordionContent);

package/Accordion/AccordionHeader.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export type AccordionHeaderProps = React.HTMLAttributes<HTMLDivElement> & {
+    readonly isOpen: boolean;
+    readonly onOpen: () => void;
+};
+declare const _default: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    readonly isOpen: boolean;
+    readonly onOpen: () => void;
+} & React.RefAttributes<HTMLDivElement>>;
+export default _default;

package/Accordion/AccordionHeader.js

@@ -0,0 +1,53 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const styled_1 = __importDefault(require("@emotion/styled"));
+const Button_1 = __importDefault(require("../Button"));
+const Chevron_1 = __importDefault(require("./Chevron"));
+const StyledHeader = styled_1.default.div `
+  padding: 1rem 1rem 1rem 1rem;
+  font-size: 1.3rem;
+  font-weight: 600;
+  border-top-left-radius: inherit;
+  border-top-right-radius: inherit;
+  display: flex;
+  cursor: pointer;
+  flex-direction: row;
+  flex-wrap: nowrap;
+  align-items: center;
+`;
+const StyledChevron = (0, styled_1.default)(Chevron_1.default, { shouldForwardProp: p => p[0] !== '$' }) `
+  transform: ${({ $isOpen }) => (!$isOpen ? 'rotate(180deg)' : 'rotate(0)')};
+  transition: all 0.3s ease-out;
+`;
+const StyledButton = (0, styled_1.default)(Button_1.default) `
+  width: 1rem;
+  height: 1rem;
+`;
+const HeaderCell = styled_1.default.div `
+  flex: 1;
+`;
+const Actions = styled_1.default.div ``;
+const AccordionHeader = (props, ref) => {
+    const { children, isOpen, onOpen } = props, nativeProps = __rest(props, ["children", "isOpen", "onOpen"]);
+    return (react_1.default.createElement(StyledHeader, Object.assign({}, nativeProps, { ref: ref, onClick: () => onOpen() }),
+        react_1.default.createElement(HeaderCell, null, children),
+        react_1.default.createElement(Actions, null,
+            react_1.default.createElement(StyledButton, { iconOnly: true, onClick: () => onOpen() },
+                react_1.default.createElement(StyledChevron, { "$isOpen": isOpen })))));
+};
+exports.default = react_1.default.forwardRef(AccordionHeader);

package/Accordion/Chevron.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export type ChevronProps = React.SVGAttributes<SVGSVGElement>;
+declare const _default: React.ForwardRefExoticComponent<ChevronProps & React.RefAttributes<SVGSVGElement>>;
+export default _default;

package/Accordion/Chevron.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const styled_1 = __importDefault(require("@emotion/styled"));
+const Path = styled_1.default.path `
+  fill: ${({ theme }) => theme.color.accentSecondary.toString()};
+`;
+const Spinner = (props, ref) => (react_1.default.createElement("svg", Object.assign({ xmlns: "http://www.w3.org/2000/svg", width: "1em", height: "1em", viewBox: "0 0 24 24" }, props, { ref: ref }),
+    react_1.default.createElement(Path, { d: "M7.41,15.41L12,10.83L16.59,15.41L18,14L12,8L6,14L7.41,15.41Z" })));
+exports.default = react_1.default.forwardRef(Spinner);

package/Accordion/index.d.ts

@@ -0,0 +1,86 @@
+import * as React from 'react';
+import { AccordionContainerProps } from './AccordionContainer';
+import { AccordionHeaderProps } from './AccordionHeader';
+import { AccordionContentProps } from './AccordionContent';
+import { AccordionActionsProps } from './AccordionActions';
+export type AccordionProps = React.HTMLAttributes<HTMLDivElement> & {
+    readonly children: React.ReactNode | React.ReactNode[];
+    /**
+     * Header content
+     */
+    readonly header?: JSX.Element | string;
+    /**
+     * Actions content
+     */
+    readonly actions?: JSX.Element | string;
+    /**
+     * Overridable components map
+     */
+    readonly overrides?: AccordionOverrides;
+    /**
+     * This props ovveride default component open state
+     */
+    readonly isOpen?: boolean;
+    /**
+     * If `true` accordion will be opened by default
+     */
+    readonly defaultOpened?: boolean;
+    /**
+     * Callback function witch should open the accordion. You can forward your own function to make accordion controlled
+     */
+    readonly onOpen?: () => void;
+    /**
+     * If `true` initial padding of accorion content would be disabled
+     */
+    readonly noPadding?: boolean;
+};
+export interface AccordionOverrides {
+    /**
+     * Accordion container component
+     */
+    readonly Container?: React.ForwardRefExoticComponent<AccordionContainerProps & React.RefAttributes<HTMLDivElement>>;
+    /**
+     * Accordion header component
+     */
+    readonly Header?: React.ForwardRefExoticComponent<AccordionHeaderProps & React.RefAttributes<HTMLDivElement>>;
+    /**
+     * Accordion content component
+     */
+    readonly Content?: React.ForwardRefExoticComponent<AccordionContentProps & React.RefAttributes<HTMLDivElement>>;
+    /**
+     * Accordion footer component
+     */
+    readonly Actions?: React.ForwardRefExoticComponent<AccordionActionsProps & React.RefAttributes<HTMLDivElement>>;
+}
+declare const _default: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    readonly children: React.ReactNode | React.ReactNode[];
+    /**
+     * Header content
+     */
+    readonly header?: string | JSX.Element | undefined;
+    /**
+     * Actions content
+     */
+    readonly actions?: string | JSX.Element | undefined;
+    /**
+     * Overridable components map
+     */
+    readonly overrides?: AccordionOverrides | undefined;
+    /**
+     * This props ovveride default component open state
+     */
+    readonly isOpen?: boolean | undefined;
+    /**
+     * If `true` accordion will be opened by default
+     */
+    readonly defaultOpened?: boolean | undefined;
+    /**
+     * Callback function witch should open the accordion. You can forward your own function to make accordion controlled
+     */
+    readonly onOpen?: (() => void) | undefined;
+    /**
+     * If `true` initial padding of accorion content would be disabled
+     */
+    readonly noPadding?: boolean | undefined;
+} & React.RefAttributes<HTMLDivElement>>;
+export default _default;

package/Accordion/index.js

@@ -0,0 +1,65 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const React = __importStar(require("react"));
+const AccordionContainer_1 = __importDefault(require("./AccordionContainer"));
+const AccordionHeader_1 = __importDefault(require("./AccordionHeader"));
+const AccordionContent_1 = __importDefault(require("./AccordionContent"));
+const AccordionActions_1 = __importDefault(require("./AccordionActions"));
+const Accordion = (props, ref) => {
+    const { children, header, actions, isOpen, onOpen, overrides, noPadding, defaultOpened } = props, nativeProps = __rest(props, ["children", "header", "actions", "isOpen", "onOpen", "overrides", "noPadding", "defaultOpened"]);
+    const hasActions = typeof actions !== 'undefined' && actions !== null;
+    const hasHeader = typeof header !== 'undefined' && header !== null;
+    const [opened, setOpened] = React.useState(typeof defaultOpened !== 'undefined' ? defaultOpened : false);
+    const overridesMap = React.useMemo(() => ({
+        Container: (overrides === null || overrides === void 0 ? void 0 : overrides.Container) || AccordionContainer_1.default,
+        Header: (overrides === null || overrides === void 0 ? void 0 : overrides.Header) || AccordionHeader_1.default,
+        Content: (overrides === null || overrides === void 0 ? void 0 : overrides.Content) || AccordionContent_1.default,
+        Actions: (overrides === null || overrides === void 0 ? void 0 : overrides.Actions) || AccordionActions_1.default,
+    }), [overrides]);
+    if (!hasHeader) {
+        console.warn(`[@via-profit/ui-kit] Accordion component. If you use a subheader, then you should add a header`);
+    }
+    return (React.createElement(overridesMap.Container, Object.assign({}, nativeProps, { ref: ref }),
+        hasHeader && (React.createElement(overridesMap.Header, { isOpen: typeof isOpen !== 'undefined' ? isOpen : opened, onOpen: onOpen ? onOpen : () => setOpened(typeof isOpen !== 'undefined' ? !isOpen : !opened) }, header)),
+        React.createElement(overridesMap.Content, { noPadding: noPadding, isOpen: typeof isOpen !== 'undefined' ? isOpen : opened },
+            children,
+            hasActions && React.createElement(overridesMap.Actions, { noPadding: noPadding }, actions))));
+};
+exports.default = React.forwardRef(Accordion);

package/Autocomplete/AutocompleteContainer.d.ts

@@ -0,0 +1,132 @@
+import React from 'react';
+import { Value, OnRequestClose, GetOptionSelected } from '../Menu';
+import { AutocompleteTextFieldProps } from './AutocompleteTextField';
+import type { AnchorPos } from '../Popper';
+import type { MenuItemCommonProps } from '../Menu/MenuItem';
+export interface AutocompleteProps<T, Multiple extends boolean | undefined = undefined> extends Omit<AutocompleteTextFieldProps, 'value' | 'onChange' | 'children' | 'overrides'> {
+    readonly items: readonly T[];
+    readonly value: Value<T, Multiple>;
+    /**
+     * Array of items. If will be array of objects or array of strings
+     */
+    readonly multiple?: Multiple;
+    /**
+     * Menu open state\
+     * If `true` then menu is open, otherwise - closed
+     */
+    readonly isOpen?: boolean;
+    /**
+     * Loading indicator visiblility\
+     * If `true` then visible, otherwise - hidden
+     */
+    /**
+     * Anchor position\
+     * \
+     * Default: `auto-start-end`
+     */
+    readonly anchorPos?: AnchorPos;
+    /**
+     * Text field loading state\
+     * If `true` then text field has been contained the loading indicator, otherwise - nop
+     */
+    readonly isLoading?: boolean;
+    /**
+     * Should the autocomplete element be cleared when blur and if no element is selected\
+     * **Default:** `true`
+     */
+    readonly clearOnBlur?: boolean;
+    /**
+     * Show clear button if clearable is true\
+     * **Default:** `true`
+     */
+    readonly clearable?: boolean;
+    /**
+     * should the Menu component opening when input focused\
+     * **Default:** `true`
+     */
+    readonly openOnFocus?: boolean;
+    /**
+     * items render function
+     */
+    readonly children: Children<T>;
+    /**
+     * A function that returns a filtered array of values. which correspond to the entered query
+     * Example:
+     * ```tsx
+     * <Autocomplete
+     *  filterItems={(items, { query }) =>
+     *    items.filter(item => item.name.toLocaleLowerCase().indexOf(query) !== -1)
+     *  }
+     *  ...
+     * >
+     * ```
+     * </Autocomplete>
+     */
+    readonly filterItems?: FilterItems<T>;
+    /**
+     * The function that will be called when an item is selected from the list
+     */
+    readonly onChange?: OnChange<T, Multiple>;
+    /**
+     * A function that transforms the selected item into a string
+     * Example:
+     * ```tsx
+     * <Autocomplete
+     *   selectedItemToString={item => item.name} // item is {id: 1, name: 'Oleg'}
+     *   ...
+     * >
+     *   ...
+     * </Autocomplete>
+     * ```
+     */
+    readonly selectedItemToString: ItemToString<T, Multiple>;
+    /**
+     * A function that determines which of the elements is currently selected\
+     * Example:
+     * ```tsx
+     * <Menu
+     *   ...
+     *   getOptionSelected={({ item, value }) => item.id === value.id}
+     */
+    readonly getOptionSelected?: GetOptionSelected<T>;
+    /**
+     * The function that will be called at the moment when you want to close the autocomplete
+     */
+    readonly onRequestClose?: OnRequestClose;
+    /**
+     * The function that will be called at the moment when you change the input value of input element
+     */
+    readonly onInputChange?: React.ChangeEventHandler<HTMLInputElement>;
+    /**
+     * The function that will be called at the moment when you want to open the selectbox
+     */
+    readonly onRequestOpen?: (event: React.KeyboardEvent<HTMLElement> | React.MouseEvent<HTMLElement> | React.FocusEvent<HTMLInputElement, Element> | React.ChangeEvent<HTMLInputElement>) => void;
+    /**
+     * Overridable components map
+     */
+    readonly overrides?: AutocompleteOverrides;
+}
+export interface AutocompleteOverrides {
+    /**
+     * Element wrapper
+     */
+    readonly TextField?: React.ForwardRefExoticComponent<AutocompleteTextFieldProps & React.RefAttributes<HTMLDivElement>>;
+}
+export type Children<T> = (data: {
+    item: T;
+    index: number;
+    inputValue: string;
+}, itemProps: MenuItemCommonProps) => React.ReactNode;
+export type ItemToString<T, Multiple extends boolean | undefined = undefined> = (item: Multiple extends undefined ? T : readonly T[]) => string;
+export type OnChange<T, Multiple extends boolean | undefined = undefined> = (item: Value<T, Multiple>) => void;
+export type FilterItems<T> = (items: readonly T[], data: {
+    readonly query: string;
+    readonly inputValue: string;
+}) => readonly T[];
+export type AutocompleteRef = {
+    clear: () => void;
+};
+declare const _default: <T, Multiple extends boolean | undefined = undefined>(props: AutocompleteProps<T, Multiple> & {
+    ref?: React.Ref<AutocompleteRef> | undefined;
+}) => JSX.Element;
+export default _default;