@mw-kit/mw-ui 1.8.22 → 1.9.0

package/dist/components/Input/components/Select/hooks/Select/interfaces.d.ts

@@ -1,6 +1,7 @@
 import type { GenericObject } from '../../../../../../interfaces';
 import type { CommonContext, CommonProps, Option } from '../interfaces';
 export interface SelectProps<T extends GenericObject = GenericObject> extends CommonProps<T> {
+    /** @deprecated use MwSelect instead */
     type: 'select';
     name?: string;
     setValue: (value: string, option: Option<T>['data']) => void;

package/dist/components/Input/components/Select/hooks/SelectMultiple/interfaces.d.ts

@@ -2,6 +2,7 @@ import type { GenericObject } from '../../../../../../interfaces';
 import type { CommonContext, CommonProps, Option } from '../interfaces';
 import type { Limits } from './utils';
 export interface SelectProps<T extends GenericObject = GenericObject> extends CommonProps<T> {
+    /** @deprecated use MwSelect instead */
     type: 'select-multiple';
     setValue: (value: string[], data: Option<T>['data'][]) => void;
     value: (Pick<Option<T>, 'value' | 'data'> | string)[];

package/dist/components/Popup/hooks/fallbackPlacements/index.d.ts

@@ -0,0 +1,3 @@
+import type { PopupPlacement, PopupProps } from '../../types';
+declare const useFallbackPlacements: (props: PopupProps) => PopupPlacement[];
+export default useFallbackPlacements;

package/dist/components/Popup/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { default as useFallbackPlacements } from './fallbackPlacements';
+export { default as useOpen } from './open';

package/dist/components/Popup/hooks/open/index.d.ts

@@ -0,0 +1,3 @@
+import type { PopupProps } from '../../types';
+declare const useOpen: (props: PopupProps) => readonly [boolean | undefined, (nextOpen: boolean) => void];
+export default useOpen;

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

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { PopupProps } from './types';
+declare const Popup: <T extends React.ElementType = "div">(props: PopupProps<T> & {
+    enabled?: boolean;
+}) => JSX.Element;
+export default Popup;

package/dist/components/Popup/styles.d.ts

@@ -0,0 +1,9 @@
+import type { PopupProps } from './types';
+export declare const TooltipArrow: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    $placement: PopupProps["placement"];
+    $arrow?: Exclude<PopupProps["arrow"], "none">;
+}>> & string;
+export declare const TooltipSurface: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    $placement: PopupProps["placement"];
+    $background?: PopupProps["background"];
+}>> & string;

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

@@ -0,0 +1,17 @@
+export type PopupProps<T extends React.ElementType = 'div'> = {
+    content: React.FunctionComponent;
+    placement: PopupPlacement;
+    on?: 'hover' | 'click';
+    triggerType?: T;
+    triggerProps?: React.ComponentPropsWithRef<T>;
+    renderTrigger: (props: React.ComponentPropsWithRef<T>) => React.ReactNode;
+    offset?: number;
+    shift?: number;
+    background?: 'light' | 'dark';
+    arrow?: 'flattened' | 'pointed' | 'none';
+    closeOnClip?: boolean;
+    open?: boolean;
+    setOpen?: (open: boolean) => void;
+    fallbackPlacements?: PopupPlacement[];
+};
+export type PopupPlacement = 'top' | 'top-start' | 'top-end' | 'right' | 'right-start' | 'right-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end';

package/dist/components/Select/components/Apply/index.d.ts

@@ -0,0 +1,7 @@
+import type { SelectMultiProps } from '../../types';
+type ApplyProps = Pick<Required<SelectMultiProps<unknown>>, 'setValue' | 'clearable' | 'applyRules'> & {
+    onClose: () => void;
+    draft: Map<string, unknown>;
+};
+declare const Apply: ({ setValue, clearable, applyRules, onClose, draft, }: ApplyProps) => import("react/jsx-runtime").JSX.Element;
+export default Apply;

package/dist/components/Select/components/Apply/styles.d.ts

@@ -0,0 +1 @@
+export declare const ApplyButton: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>> & string;

package/dist/components/Select/components/Scroll/index.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { VirtualItem, Virtualizer } from '@tanstack/react-virtual';
+import type { SelectKeyBuilder, SelectOptionComponent, SelectRule } from '../../types';
+declare const Scroll: React.ForwardRefExoticComponent<{
+    menuId: string;
+    options: unknown[];
+    virtualItems: VirtualItem[];
+    loading: boolean;
+    totalSize: number;
+    measureElement: Virtualizer<Element, Element>["measureElement"];
+    OptionComponent: SelectOptionComponent<unknown>;
+    onClickOption: (index: number) => void;
+    onMouseEnterOption: (index: number) => void;
+    activeIndex: number;
+    getKey: SelectKeyBuilder<unknown>;
+    getIsSelected: (key: string) => boolean;
+    getFailedRuleByKey: Map<string, SelectRule<unknown>>["get"];
+    mode: "single" | "multi";
+} & Pick<React.HTMLAttributes<HTMLDivElement>, "aria-multiselectable"> & React.RefAttributes<HTMLDivElement>>;
+export default Scroll;

package/dist/components/Select/components/Scroll/styles.d.ts

@@ -0,0 +1,9 @@
+export declare const ListContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const ListScroll: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const ListInner: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const EmptyMessage: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const MultiHighlight: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const SingleHighlight: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const OptionRow: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    $active: boolean;
+}>> & string;

package/dist/components/Select/components/Search/index.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+declare const Search: React.ForwardRefExoticComponent<{
+    menuId: string;
+    value: [string, (input: string) => void];
+    activeIndex: number;
+} & Required<Pick<React.HTMLAttributes<HTMLInputElement>, "onKeyDown">> & React.RefAttributes<HTMLInputElement>>;
+export default Search;

package/dist/components/Select/components/Search/styles.d.ts

@@ -0,0 +1 @@
+export declare const SearchContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

package/dist/components/Select/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const SEARCH_DEBOUNCE_MS = 500;
+export declare const MENU_EXIT_MS = 250;

package/dist/components/Select/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export { default as useAsyncOptions } from './useAsyncOptions';
+export { default as useFloatingMenu } from './useFloatingMenu';
+export { default as useListNavigation } from './useListNavigation';
+export { default as useRuleIndex } from './useRuleIndex';
+export { default as useVirtualizedOptions } from './useVirtualizedOptions';

package/dist/components/Select/hooks/useAsyncOptions/index.d.ts

@@ -0,0 +1,8 @@
+import type { SelectOptionsLoader } from '../../types';
+declare const useAsyncOptions: <Option>(loader: SelectOptionsLoader<Option>) => {
+    readonly options: Option[];
+    readonly loading: boolean;
+    readonly paginate: () => void;
+    readonly searchInput: readonly [string, (input: string) => void];
+};
+export default useAsyncOptions;

package/dist/components/Select/hooks/useFloatingMenu/index.d.ts

@@ -0,0 +1,50 @@
+type UseFloatingMenuParams = {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+};
+declare const useFloatingMenu: ({ open, onOpenChange }: UseFloatingMenuParams) => {
+    floating: {
+        placement: import("@floating-ui/utils").Placement;
+        strategy: import("@floating-ui/utils").Strategy;
+        middlewareData: import("@floating-ui/core").MiddlewareData;
+        x: number;
+        y: number;
+        isPositioned: boolean;
+        update: () => void;
+        floatingStyles: React.CSSProperties;
+        refs: {
+            reference: import("react").MutableRefObject<import("@floating-ui/react-dom").ReferenceType | null>;
+            floating: React.MutableRefObject<HTMLElement | null>;
+            setReference: (node: import("@floating-ui/react-dom").ReferenceType | null) => void;
+            setFloating: (node: HTMLElement | null) => void;
+        } & import("@floating-ui/react").ExtendedRefs<import("@floating-ui/react").ReferenceType>;
+        elements: {
+            reference: import("@floating-ui/react-dom").ReferenceType | null;
+            floating: HTMLElement | null;
+        } & import("@floating-ui/react").ExtendedElements<import("@floating-ui/react").ReferenceType>;
+        context: {
+            x: number;
+            y: number;
+            placement: import("@floating-ui/utils").Placement;
+            strategy: import("@floating-ui/utils").Strategy;
+            middlewareData: import("@floating-ui/core").MiddlewareData;
+            isPositioned: boolean;
+            update: () => void;
+            floatingStyles: React.CSSProperties;
+            open: boolean;
+            onOpenChange: (open: boolean, event?: Event, reason?: import("@floating-ui/react").OpenChangeReason) => void;
+            events: import("@floating-ui/react").FloatingEvents;
+            dataRef: React.MutableRefObject<import("@floating-ui/react").ContextData>;
+            nodeId: string | undefined;
+            floatingId: string | undefined;
+            refs: import("@floating-ui/react").ExtendedRefs<import("@floating-ui/react").ReferenceType>;
+            elements: import("@floating-ui/react").ExtendedElements<import("@floating-ui/react").ReferenceType>;
+        };
+    };
+    transition: {
+        isMounted: boolean;
+        status: "open" | "close" | "initial" | "unmounted";
+    };
+    interactions: import("@floating-ui/react").UseInteractionsReturn;
+};
+export default useFloatingMenu;

package/dist/components/Select/hooks/useListNavigation/index.d.ts

@@ -0,0 +1,13 @@
+import type { KeyboardEvent } from 'react';
+type Params = {
+    itemCount: number;
+    isItemDisabled: (index: number) => boolean;
+    onSelect: (index: number) => void;
+    scrollToIndex?: (index: number) => void;
+};
+declare const useListNavigation: ({ itemCount, isItemDisabled, onSelect, scrollToIndex, }: Params) => {
+    activeIndex: number;
+    onMouseEnter: (index: number) => void;
+    onKeyDown: (event: KeyboardEvent) => void;
+};
+export default useListNavigation;

package/dist/components/Select/hooks/useRuleIndex/index.d.ts

@@ -0,0 +1,11 @@
+import type { SelectKeyBuilder, SelectRule, SelectRules } from '../../types';
+type UseRuleIndexParams<Option> = {
+    options: readonly Option[];
+    getKey: SelectKeyBuilder<Option>;
+    rules?: SelectRules<Option>;
+};
+declare const useRuleIndex: <Option>({ options, getKey, rules, }: UseRuleIndexParams<Option>) => {
+    getFailedRuleByKey: (key: string) => SelectRule<Option> | undefined;
+    enabledCount: number;
+};
+export default useRuleIndex;

package/dist/components/Select/hooks/useVirtualizedOptions/index.d.ts

@@ -0,0 +1,13 @@
+import type { CommonSelectProps } from '../../types';
+type Params = {
+    optionsLength: number;
+    loading: boolean;
+    onPaginate: () => void;
+} & Pick<CommonSelectProps<unknown>, 'overscan' | 'estimateSize'>;
+declare const useVirtualizedOptions: (params: Params) => {
+    listRef: import("react").MutableRefObject<HTMLDivElement | null>;
+    searchRef: import("react").MutableRefObject<HTMLInputElement | null>;
+    rowVirtualizer: import("@tanstack/virtual-core").Virtualizer<HTMLDivElement, Element>;
+    virtualItems: import("@tanstack/virtual-core").VirtualItem[];
+};
+export default useVirtualizedOptions;

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

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { SelectProps } from './types';
+declare const _default: (<Option>(props: SelectProps<Option>) => JSX.Element) & {
+    OptionContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+};
+export default _default;

package/dist/components/Select/instances/index.d.ts

@@ -0,0 +1,3 @@
+import type { SelectProps, UseSelect } from './types';
+declare const useSelect: (props: SelectProps<unknown>) => ReturnType<UseSelect>;
+export default useSelect;

package/dist/components/Select/instances/multi/index.d.ts

@@ -0,0 +1,3 @@
+import type { SelectMultiProps, UseSelect } from '../types';
+declare const useMultiSelect: UseSelect<SelectMultiProps<unknown>>;
+export default useMultiSelect;

package/dist/components/Select/instances/single/index.d.ts

@@ -0,0 +1,3 @@
+import type { SelectSingleProps, UseSelect } from '../types';
+declare const useSingleSelect: UseSelect<SelectSingleProps<unknown>>;
+export default useSingleSelect;

package/dist/components/Select/instances/styles.d.ts

@@ -0,0 +1,3 @@
+export declare const Header: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const DraftSwitch: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>> & string;
+export declare const SelectAllButton: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>> & string;

package/dist/components/Select/instances/types.d.ts

@@ -0,0 +1,12 @@
+import type { CommonSelectProps, SelectButtonProps } from '../types';
+export type UseSelect<Props extends CommonSelectProps<unknown> = CommonSelectProps<unknown>> = (props: Props) => {
+    placeholder: React.ReactNode;
+    isEmpty: boolean;
+    onClear: () => void;
+    Component: React.FunctionComponent<Props & {
+        menuId: string;
+        onClose: () => void;
+    }>;
+    buttonProps: SelectButtonProps;
+};
+export * from '../types';

package/dist/components/Select/styles.d.ts

@@ -0,0 +1,14 @@
+export declare const FloatingWrapper: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+type TriggerProps = {
+    $empty: boolean;
+    $open: boolean;
+    $viewMode: boolean | undefined;
+};
+export declare const Trigger: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, TriggerProps>> & string;
+export declare const TriggerValue: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+type LabelProps = {
+    $viewMode: boolean | undefined;
+};
+export declare const Label: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, LabelProps>> & string;
+export declare const OptionContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export {};

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

@@ -0,0 +1,75 @@
+import type React from 'react';
+import type { ReactVirtualizerOptions } from '@tanstack/react-virtual';
+export type SelectOptionsLoader<Option> = (search: string, page: number, cursor: Option | null) => Promise<{
+    options: Option[];
+    last: boolean;
+} | null>;
+export type SelectOptionsFinder<Option> = (search: string, options: Option[]) => Option[];
+export type SelectKeyBuilder<Option> = (option: Option) => string;
+export type SelectRuleComponent<Option> = React.FunctionComponent<{
+    option: Option;
+}>;
+export type SelectRule<Option, Id extends string = string> = {
+    id: Id;
+    allow: (option: Option) => boolean;
+    Component?: SelectRuleComponent<Option>;
+};
+export type SelectRules<T> = readonly SelectRule<T, string>[];
+export type SelectApplyRuleComponent<Option> = React.FunctionComponent<{
+    value: Option[];
+}>;
+export type SelectApplyRule<Option, Id extends string = string> = {
+    id: Id;
+    allow: (option: Option[]) => boolean;
+    Component?: SelectApplyRuleComponent<Option>;
+};
+export type SelectApplyRules<T> = readonly SelectApplyRule<T, string>[];
+export type SelectOptionComponent<Option> = React.FunctionComponent<{
+    option: Option;
+    isActive: boolean;
+    isSelected: boolean;
+    isDisabled: boolean;
+}>;
+export type SelectButtonProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'type' | 'value' | 'role' | 'aria-haspopup' | 'aria-expanded' | 'aria-controls' | 'aria-readonly' | 'aria-invalid' | 'aria-required'>;
+export type CommonSelectProps<Option> = SelectButtonProps & {
+    label?: React.ReactNode;
+    loader: SelectOptionsLoader<Option>;
+    getKey: SelectKeyBuilder<Option>;
+    OptionComponent: SelectOptionComponent<Option>;
+    rules?: SelectRules<Option>;
+    placeholder?: string;
+    required?: boolean;
+    invalid?: boolean;
+    clearable?: boolean;
+    readOnly?: boolean;
+    viewMode?: boolean;
+    /**
+     * The number of items to render above and below the visible area.
+     * The default is 2.
+     * @see https://tanstack.com/virtual/latest/docs/api/virtualizer#overscan
+     */
+    overscan?: ReactVirtualizerOptions<Element, Element>['overscan'];
+    /**
+     * This function is passed the index of each item and should return the actual size (or estimated size if you will be dynamically measuring items with virtualItem.measureElement) for each item.
+     * The default is 46.
+     * @see https://tanstack.com/virtual/latest/docs/api/virtualizer#estimatesize
+     */
+    estimateSize?: ReactVirtualizerOptions<Element, Element>['estimateSize'] | number;
+    height?: number;
+};
+export type SelectSingleProps<Option> = CommonSelectProps<Option> & {
+    value: Option | null;
+    setValue: (value: Option | null) => void;
+    ValueComponent?: SelectOptionComponent<Option>;
+};
+export type SelectMultiProps<Option> = CommonSelectProps<Option> & {
+    value: Option[];
+    setValue: (value: Option[]) => void;
+    finder: SelectOptionsFinder<Option>;
+    applyRules?: SelectApplyRules<Option>;
+};
+export type SelectProps<Option> = ({
+    type: 'single-select';
+} & SelectSingleProps<Option>) | ({
+    type: 'multi-select';
+} & SelectMultiProps<Option>);

package/dist/components/index.d.ts

@@ -17,6 +17,7 @@ export { default as MwModal } from './Modal';
 export { default as MwPlaceholder } from './Placeholder';
 export { default as MwProgressBar } from './ProgressBar';
 export { default as MwScrollContainer } from './ScrollContainer';
+export { default as MwSelect } from './Select';
 export { default as MwSignature } from './Signature';
 export { default as MwTabs } from './Tabs';
 export { default as MwTextArea } from './TextArea';

package/dist/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export { default as useDebouncedCallback } from './useDebouncedCallback';
+export { default as useDebouncedState } from './useDebouncedState';
+export { default as useOnClickOut } from './useOnClickOut';

package/dist/hooks/useDebouncedCallback/index.d.ts

@@ -0,0 +1,8 @@
+export type DebouncedFunction<T extends (...args: never[]) => unknown> = {
+    (...args: Parameters<T>): void;
+    cancel: () => void;
+    flush: () => void;
+};
+export declare const debounce: <T extends (...args: never[]) => unknown>(fn: T, delay: number) => DebouncedFunction<T>;
+export declare const useDebouncedCallback: <T extends (...args: never[]) => unknown>(callback: T, delay: number) => DebouncedFunction<T>;
+export default useDebouncedCallback;

package/dist/hooks/useDebouncedState/index.d.ts

@@ -0,0 +1,5 @@
+declare const useDebouncedState: <T>(initial: T, onUpdate: () => void, ms: number) => {
+    readonly current: readonly [T, (input: T) => void];
+    readonly debounced: readonly [T, (value: T) => void];
+};
+export default useDebouncedState;

package/dist/index.d.mts

@@ -4,6 +4,8 @@ import * as React$1 from 'react';
 import React__default, { TextareaHTMLAttributes } from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { PopupProps, SemanticICONS } from 'semantic-ui-react';
+import * as styled_components_dist_types from 'styled-components/dist/types';
+import { ReactVirtualizerOptions } from '@tanstack/react-virtual';
 import SignatureCanvas, { SignatureCanvasProps } from 'react-signature-canvas';
 
 type TransitionFunction = 'ease' | 'ease-in' | 'ease-out' | 'ease-in-out' | 'linear' | 'step-start' | 'step-end' | `cubic-bezier(${number}, ${number}, ${number}, ${number})` | `frames(${number})` | `steps(${number})` | `steps(${number}, ${'jump-start' | 'jump-end' | 'jump-none' | 'jump-both' | 'start' | 'end'})`;
@@ -855,8 +857,82 @@ interface TabsProps<T = EmptyObject, C extends string = string> extends Omit<Rea
 }
 type TabsComponent = <T = EmptyObject, C extends string = string>(props: TabsProps<T, C>) => JSX.Element;
 
-type Element = JSX.Element | string | number | boolean | null;
-type ReactNode = Element | Element[];
+type SelectOptionsLoader<Option> = (search: string, page: number, cursor: Option | null) => Promise<{
+    options: Option[];
+    last: boolean;
+} | null>;
+type SelectOptionsFinder<Option> = (search: string, options: Option[]) => Option[];
+type SelectKeyBuilder<Option> = (option: Option) => string;
+type SelectRuleComponent<Option> = React__default.FunctionComponent<{
+    option: Option;
+}>;
+type SelectRule<Option, Id extends string = string> = {
+    id: Id;
+    allow: (option: Option) => boolean;
+    Component?: SelectRuleComponent<Option>;
+};
+type SelectRules<T> = readonly SelectRule<T, string>[];
+type SelectApplyRuleComponent<Option> = React__default.FunctionComponent<{
+    value: Option[];
+}>;
+type SelectApplyRule<Option, Id extends string = string> = {
+    id: Id;
+    allow: (option: Option[]) => boolean;
+    Component?: SelectApplyRuleComponent<Option>;
+};
+type SelectApplyRules<T> = readonly SelectApplyRule<T, string>[];
+type SelectOptionComponent<Option> = React__default.FunctionComponent<{
+    option: Option;
+    isActive: boolean;
+    isSelected: boolean;
+    isDisabled: boolean;
+}>;
+type SelectButtonProps = Omit<React__default.ButtonHTMLAttributes<HTMLButtonElement>, 'type' | 'value' | 'role' | 'aria-haspopup' | 'aria-expanded' | 'aria-controls' | 'aria-readonly' | 'aria-invalid' | 'aria-required'>;
+type CommonSelectProps<Option> = SelectButtonProps & {
+    label?: React__default.ReactNode;
+    loader: SelectOptionsLoader<Option>;
+    getKey: SelectKeyBuilder<Option>;
+    OptionComponent: SelectOptionComponent<Option>;
+    rules?: SelectRules<Option>;
+    placeholder?: string;
+    required?: boolean;
+    invalid?: boolean;
+    clearable?: boolean;
+    readOnly?: boolean;
+    viewMode?: boolean;
+    /**
+     * The number of items to render above and below the visible area.
+     * The default is 2.
+     * @see https://tanstack.com/virtual/latest/docs/api/virtualizer#overscan
+     */
+    overscan?: ReactVirtualizerOptions<Element, Element>['overscan'];
+    /**
+     * This function is passed the index of each item and should return the actual size (or estimated size if you will be dynamically measuring items with virtualItem.measureElement) for each item.
+     * The default is 46.
+     * @see https://tanstack.com/virtual/latest/docs/api/virtualizer#estimatesize
+     */
+    estimateSize?: ReactVirtualizerOptions<Element, Element>['estimateSize'] | number;
+    height?: number;
+};
+type SelectSingleProps<Option> = CommonSelectProps<Option> & {
+    value: Option | null;
+    setValue: (value: Option | null) => void;
+    ValueComponent?: SelectOptionComponent<Option>;
+};
+type SelectMultiProps<Option> = CommonSelectProps<Option> & {
+    value: Option[];
+    setValue: (value: Option[]) => void;
+    finder: SelectOptionsFinder<Option>;
+    applyRules?: SelectApplyRules<Option>;
+};
+type SelectProps$3<Option> = ({
+    type: 'single-select';
+} & SelectSingleProps<Option>) | ({
+    type: 'multi-select';
+} & SelectMultiProps<Option>);
+
+type Element$1 = JSX.Element | string | number | boolean | null;
+type ReactNode = Element$1 | Element$1[];
 type GenericObject = Record<string | number | symbol, any>;
 type EmptyObject = Record<string, never>;
 type SpacingOrZero = keyof typeof spacings | '0';
@@ -1390,6 +1466,7 @@ interface RangeProps extends Omit<React__default.InputHTMLAttributes<HTMLInputEl
 }
 
 interface SelectProps$2<T extends GenericObject = GenericObject> extends CommonProps$1<T> {
+    /** @deprecated use MwSelect instead */
     type: 'select';
     name?: string;
     setValue: (value: string, option: Option$1<T>['data']) => void;
@@ -1399,6 +1476,7 @@ interface SelectProps$2<T extends GenericObject = GenericObject> extends CommonP
 }
 
 interface SelectProps$1<T extends GenericObject = GenericObject> extends CommonProps$1<T> {
+    /** @deprecated use MwSelect instead */
     type: 'select-multiple';
     setValue: (value: string[], data: Option$1<T>['data'][]) => void;
     value: (Pick<Option$1<T>, 'value' | 'data'> | string)[];
@@ -1567,6 +1645,10 @@ declare const ProgressBar: ({ type, value, ...props }: ProgressBarProps) => reac
 
 declare const ScrollContainer: React__default.ForwardRefExoticComponent<ScrollContainerProps & React__default.RefAttributes<HTMLDivElement>>;
 
+declare const _default: (<Option>(props: SelectProps$3<Option>) => JSX.Element) & {
+    OptionContainer: styled_components_dist_types.IStyledComponentBase<"web", styled_components.FastOmit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+};
+
 type SignatureInputProps = {
     setValue: (base64: string) => void;
     value: string;
@@ -1631,4 +1713,4 @@ declare const ThemeProvider: (props: React.PropsWithChildren<{
     assetBaseUrl: string;
 }>) => react_jsx_runtime.JSX.Element;
 
-export { AbsoluteContainer as MwAbsoluteContainer, AppliedFilters as MwAppliedFilters, Button as MwButton, Calendar as MwCalendar, Card as MwCard, EllipsisContainer as MwEllipsisContainer, Filters as MwFilters, Form as MwForm, Grid as MwGrid, Icon as MwIcon, Indicator as MwIndicator, Input as MwInput, Link as MwLink, Loader as MwLoader, Menu as MwMenu, Modal as MwModal, Placeholder as MwPlaceholder, ProgressBar as MwProgressBar, ScrollContainer as MwScrollContainer, SignatureInput as MwSignature, Tabs as MwTabs, TextArea as MwTextArea, Toast as MwToast, Transition as MwTransition, Zoom as MwZoom, ThemeProvider, theme, useTransition as useMwTransition };
+export { AbsoluteContainer as MwAbsoluteContainer, AppliedFilters as MwAppliedFilters, Button as MwButton, Calendar as MwCalendar, Card as MwCard, EllipsisContainer as MwEllipsisContainer, Filters as MwFilters, Form as MwForm, Grid as MwGrid, Icon as MwIcon, Indicator as MwIndicator, Input as MwInput, Link as MwLink, Loader as MwLoader, Menu as MwMenu, Modal as MwModal, Placeholder as MwPlaceholder, ProgressBar as MwProgressBar, ScrollContainer as MwScrollContainer, _default as MwSelect, SignatureInput as MwSignature, Tabs as MwTabs, TextArea as MwTextArea, Toast as MwToast, Transition as MwTransition, Zoom as MwZoom, ThemeProvider, theme, useTransition as useMwTransition };