@sellgar/kit 0.0.40 → 0.0.41

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@sellgar/kit",
-  "version": "0.0.40",
+  "version": "0.0.41",
   "description": "Sellgar storybook",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -37,6 +37,8 @@
     "@floating-ui/react": "0.27.4",
     "@types/react-slider": "1.3.6",
     "classnames": "2.5.1",
+    "overlayscrollbars": "2.11.1",
+    "react-baron": "3.0.0",
     "react-calendar": "5.1.0",
     "react-slider": "2.0.6"
   },

package/types/components/helpers/dropdown/dropdown.d.ts

@@ -0,0 +1,138 @@
+import { ReferenceType } from '@floating-ui/react';
+import { default as React } from 'react';
+interface IOptions {
+    initialOpen?: boolean;
+    open?: boolean;
+    setOpen?(open: boolean): void;
+}
+declare const useDropdown: (options: IOptions) => {
+    open: boolean | undefined;
+    setOpen: (open: boolean) => void;
+    role: import('@floating-ui/react').ElementProps;
+    dismiss: import('@floating-ui/react').ElementProps;
+    listRef: React.RefObject<(HTMLElement | null)[]>;
+    listContentRef: React.RefObject<(string | null)[]>;
+    activeIndex: number | null;
+    setActiveIndex: React.Dispatch<React.SetStateAction<number | null>>;
+    selectedIndex: number | null;
+    setSelectedIndex: React.Dispatch<React.SetStateAction<number | null>>;
+    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: 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<ReferenceType>;
+        elements: {
+            reference: import('@floating-ui/react-dom').ReferenceType | null;
+            floating: HTMLElement | null;
+        } & import('@floating-ui/react').ExtendedElements<ReferenceType>;
+        context: {
+            update: () => void;
+            placement: import('@floating-ui/utils').Placement;
+            strategy: import('@floating-ui/utils').Strategy;
+            x: number;
+            y: number;
+            middlewareData: import('@floating-ui/core').MiddlewareData;
+            isPositioned: boolean;
+            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<ReferenceType>;
+            elements: import('@floating-ui/react').ExtendedElements<ReferenceType>;
+        };
+    };
+    interactions: import('@floating-ui/react').UseInteractionsReturn;
+};
+type TDropdownContext = ReturnType<typeof useDropdown>;
+export declare const useDropdownContext: () => {
+    open: boolean | undefined;
+    setOpen: (open: boolean) => void;
+    role: import('@floating-ui/react').ElementProps;
+    dismiss: import('@floating-ui/react').ElementProps;
+    listRef: React.RefObject<(HTMLElement | null)[]>;
+    listContentRef: React.RefObject<(string | null)[]>;
+    activeIndex: number | null;
+    setActiveIndex: React.Dispatch<React.SetStateAction<number | null>>;
+    selectedIndex: number | null;
+    setSelectedIndex: React.Dispatch<React.SetStateAction<number | null>>;
+    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: 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<ReferenceType>;
+        elements: {
+            reference: import('@floating-ui/react-dom').ReferenceType | null;
+            floating: HTMLElement | null;
+        } & import('@floating-ui/react').ExtendedElements<ReferenceType>;
+        context: {
+            update: () => void;
+            placement: import('@floating-ui/utils').Placement;
+            strategy: import('@floating-ui/utils').Strategy;
+            x: number;
+            y: number;
+            middlewareData: import('@floating-ui/core').MiddlewareData;
+            isPositioned: boolean;
+            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<ReferenceType>;
+            elements: import('@floating-ui/react').ExtendedElements<ReferenceType>;
+        };
+    };
+    interactions: import('@floating-ui/react').UseInteractionsReturn;
+};
+interface IProps {
+    initialOpen?: boolean;
+    open?: boolean;
+    setOpen?(open: boolean): void;
+}
+declare const DropdownWrapper: React.FC<React.PropsWithChildren<IProps>>;
+interface IReferenceProps {
+    reference(context: TDropdownContext): React.ReactNode;
+}
+declare const Reference: React.MemoExoticComponent<(props: IReferenceProps) => React.JSX.Element>;
+interface IOptionsProps {
+    empty: React.ReactNode;
+    options(context: TDropdownContext): React.ReactNode[];
+}
+declare const Options: React.MemoExoticComponent<(props: IOptionsProps) => React.JSX.Element | null>;
+interface IOptionProps {
+    index: number;
+    onClick?(event: React.MouseEvent<HTMLElement>): void;
+    option(context: TDropdownContext): React.ReactNode;
+}
+declare const Option: React.MemoExoticComponent<(props: IOptionProps) => React.JSX.Element>;
+type TDropdown = typeof DropdownWrapper & {
+    Reference: typeof Reference;
+    Options: typeof Options;
+    Option: typeof Option;
+};
+export declare const Dropdown: TDropdown;
+export {};

package/types/components/helpers/dropdown/index.d.ts

@@ -0,0 +1 @@
+export { Dropdown } from './dropdown.tsx';

package/types/components/helpers/dropdown2/dropdown.d.ts

@@ -0,0 +1,138 @@
+import { ReferenceType } from '@floating-ui/react';
+import { default as React } from 'react';
+interface IOptions {
+    initialOpen?: boolean;
+    open?: boolean;
+    setOpen?(open: boolean): void;
+}
+declare const useDropdown: (options: IOptions) => {
+    open: boolean | undefined;
+    setOpen: (open: boolean) => void;
+    role: import('@floating-ui/react').ElementProps;
+    dismiss: import('@floating-ui/react').ElementProps;
+    listRef: React.RefObject<(HTMLElement | null)[]>;
+    listContentRef: React.RefObject<(string | null)[]>;
+    activeIndex: number | null;
+    setActiveIndex: React.Dispatch<React.SetStateAction<number | null>>;
+    selectedIndex: number | null;
+    setSelectedIndex: React.Dispatch<React.SetStateAction<number | null>>;
+    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: 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<ReferenceType>;
+        elements: {
+            reference: import('@floating-ui/react-dom').ReferenceType | null;
+            floating: HTMLElement | null;
+        } & import('@floating-ui/react').ExtendedElements<ReferenceType>;
+        context: {
+            update: () => void;
+            placement: import('@floating-ui/utils').Placement;
+            strategy: import('@floating-ui/utils').Strategy;
+            x: number;
+            y: number;
+            middlewareData: import('@floating-ui/core').MiddlewareData;
+            isPositioned: boolean;
+            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<ReferenceType>;
+            elements: import('@floating-ui/react').ExtendedElements<ReferenceType>;
+        };
+    };
+    interactions: import('@floating-ui/react').UseInteractionsReturn;
+};
+type TDropdownContext = ReturnType<typeof useDropdown>;
+export declare const useDropdownContext: () => {
+    open: boolean | undefined;
+    setOpen: (open: boolean) => void;
+    role: import('@floating-ui/react').ElementProps;
+    dismiss: import('@floating-ui/react').ElementProps;
+    listRef: React.RefObject<(HTMLElement | null)[]>;
+    listContentRef: React.RefObject<(string | null)[]>;
+    activeIndex: number | null;
+    setActiveIndex: React.Dispatch<React.SetStateAction<number | null>>;
+    selectedIndex: number | null;
+    setSelectedIndex: React.Dispatch<React.SetStateAction<number | null>>;
+    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: 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<ReferenceType>;
+        elements: {
+            reference: import('@floating-ui/react-dom').ReferenceType | null;
+            floating: HTMLElement | null;
+        } & import('@floating-ui/react').ExtendedElements<ReferenceType>;
+        context: {
+            update: () => void;
+            placement: import('@floating-ui/utils').Placement;
+            strategy: import('@floating-ui/utils').Strategy;
+            x: number;
+            y: number;
+            middlewareData: import('@floating-ui/core').MiddlewareData;
+            isPositioned: boolean;
+            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<ReferenceType>;
+            elements: import('@floating-ui/react').ExtendedElements<ReferenceType>;
+        };
+    };
+    interactions: import('@floating-ui/react').UseInteractionsReturn;
+};
+interface IProps {
+    initialOpen?: boolean;
+    open?: boolean;
+    setOpen?(open: boolean): void;
+}
+declare const DropdownWrapper: React.FC<React.PropsWithChildren<IProps>>;
+interface IReferenceProps {
+    reference(context: TDropdownContext): React.ReactNode;
+}
+declare const Reference: React.MemoExoticComponent<(props: IReferenceProps) => React.JSX.Element>;
+interface IOptionsProps {
+    empty: React.ReactNode;
+    options(context: TDropdownContext): React.ReactNode[];
+}
+declare const Options: React.MemoExoticComponent<(props: IOptionsProps) => React.JSX.Element | null>;
+interface IOptionProps {
+    index: number;
+    onClick?(event: React.MouseEvent<HTMLElement>): void;
+    option(context: TDropdownContext): React.ReactNode;
+}
+declare const Option: React.MemoExoticComponent<(props: IOptionProps) => React.JSX.Element>;
+type TDropdown = typeof DropdownWrapper & {
+    Reference: typeof Reference;
+    Options: typeof Options;
+    Option: typeof Option;
+};
+export declare const Dropdown: TDropdown;
+export {};

package/types/components/helpers/dropdown2/index.d.ts

@@ -0,0 +1 @@
+export { Dropdown } from './dropdown.tsx';

package/types/components/helpers/select/index.d.ts

@@ -0,0 +1 @@
+export { Select } from './select.tsx';

package/types/components/helpers/select/select.d.ts

@@ -0,0 +1,139 @@
+import { ReferenceType } from '@floating-ui/react';
+import { default as React } from 'react';
+interface IOptions {
+    initialOpen?: boolean;
+    initialSelectedIndex?: number;
+    open?: boolean;
+    setOpen?(open: boolean): void;
+}
+declare const useSelect: (options: IOptions) => {
+    open: boolean | undefined;
+    setOpen: (open: boolean) => void;
+    role: import('@floating-ui/react').ElementProps;
+    dismiss: import('@floating-ui/react').ElementProps;
+    listRef: React.RefObject<(HTMLElement | null)[]>;
+    activeIndex: number | null;
+    setActiveIndex: React.Dispatch<React.SetStateAction<number | null>>;
+    selectedIndex: number | null;
+    setSelectedIndex: React.Dispatch<React.SetStateAction<number | null>>;
+    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: 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<ReferenceType>;
+        elements: {
+            reference: import('@floating-ui/react-dom').ReferenceType | null;
+            floating: HTMLElement | null;
+        } & import('@floating-ui/react').ExtendedElements<ReferenceType>;
+        context: {
+            update: () => void;
+            placement: import('@floating-ui/utils').Placement;
+            strategy: import('@floating-ui/utils').Strategy;
+            x: number;
+            y: number;
+            middlewareData: import('@floating-ui/core').MiddlewareData;
+            isPositioned: boolean;
+            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<ReferenceType>;
+            elements: import('@floating-ui/react').ExtendedElements<ReferenceType>;
+        };
+    };
+    interactions: import('@floating-ui/react').UseInteractionsReturn;
+};
+type TSelectContext = ReturnType<typeof useSelect>;
+export declare const useSelectContext: () => {
+    open: boolean | undefined;
+    setOpen: (open: boolean) => void;
+    role: import('@floating-ui/react').ElementProps;
+    dismiss: import('@floating-ui/react').ElementProps;
+    listRef: React.RefObject<(HTMLElement | null)[]>;
+    activeIndex: number | null;
+    setActiveIndex: React.Dispatch<React.SetStateAction<number | null>>;
+    selectedIndex: number | null;
+    setSelectedIndex: React.Dispatch<React.SetStateAction<number | null>>;
+    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: 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<ReferenceType>;
+        elements: {
+            reference: import('@floating-ui/react-dom').ReferenceType | null;
+            floating: HTMLElement | null;
+        } & import('@floating-ui/react').ExtendedElements<ReferenceType>;
+        context: {
+            update: () => void;
+            placement: import('@floating-ui/utils').Placement;
+            strategy: import('@floating-ui/utils').Strategy;
+            x: number;
+            y: number;
+            middlewareData: import('@floating-ui/core').MiddlewareData;
+            isPositioned: boolean;
+            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<ReferenceType>;
+            elements: import('@floating-ui/react').ExtendedElements<ReferenceType>;
+        };
+    };
+    interactions: import('@floating-ui/react').UseInteractionsReturn;
+};
+interface IProps {
+    initialOpen?: boolean;
+    initialSelectedIndex?: number;
+    open?: boolean;
+    setOpen?(open: boolean): void;
+}
+declare const SelectWrapper: React.FC<React.PropsWithChildren<IProps>>;
+interface IReferenceProps {
+    reference(context: TSelectContext): React.ReactNode;
+}
+declare const Reference: React.MemoExoticComponent<(props: IReferenceProps) => React.JSX.Element>;
+interface IOptionsProps {
+    empty: React.ReactNode;
+    options(context: TSelectContext): React.ReactNode[];
+}
+declare const Options: React.MemoExoticComponent<(props: IOptionsProps) => React.JSX.Element | null>;
+interface IOptionProps {
+    index: number;
+    option(context: TSelectContext): React.ReactNode;
+    onClick?(event: React.MouseEvent<HTMLElement>): void;
+    onChange?(event: React.KeyboardEvent<HTMLElement>): void;
+}
+declare const Option: React.MemoExoticComponent<(props: IOptionProps) => React.JSX.Element>;
+type TSelect = typeof SelectWrapper & {
+    Reference: typeof Reference;
+    Options: typeof Options;
+    Option: typeof Option;
+};
+export declare const Select: TSelect;
+export {};

package/types/components/misc/base-option/base-option.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+interface IProps {
+    leadicon?: React.ReactNode;
+    active?: boolean;
+    label: string;
+    badge?: string;
+    toggle?: boolean;
+}
+export declare const BaseOption: React.FC<IProps>;
+export {};

package/types/components/misc/base-option/index.d.ts

@@ -0,0 +1 @@
+export { BaseOption } from './base-option.tsx';

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

@@ -1,3 +1,4 @@
 export * from './dot';
 export * from './divider';
 export * from './menu-item';
+export * from './base-option';

package/types/components/symbols/button-dropdown/button-dropdown.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { TIconName } from '../icon';
+interface IProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'style'> {
+    form?: 'icon-only';
+    style?: 'primary' | 'secondary' | 'tertiary' | 'ghost';
+    size?: 'lg' | 'md' | 'sm' | 'xs';
+    target?: 'destructive';
+    shape?: 'rounded' | 'pill';
+    leadicon?: TIconName;
+    tailicon?: TIconName;
+    label?: string | number;
+}
+export declare const ButtonDropdown: React.FC<IProps>;
+export {};

package/types/components/symbols/button-dropdown/index.d.ts

@@ -0,0 +1 @@
+export { ButtonDropdown } from './button-dropdown.tsx';

package/types/components/symbols/dropdown/dropdown.d.ts

@@ -0,0 +1,26 @@
+import { default as React } from 'react';
+interface IReferenceProps<T extends Record<string, any>, K extends keyof T> {
+    activeIndex: number | null;
+    selectedIndex: number | null;
+    setActive(index: number | null): void;
+}
+interface IOptionProps<T extends Record<string, any>, K extends keyof T> {
+    option: T;
+    value: T[K];
+    active: boolean;
+    selected: boolean;
+    activeIndex: number | null;
+    selectedIndex: number | null;
+    setActive(index: number | null): void;
+}
+export interface IProps<T extends Record<string, any>, K extends keyof T> {
+    open?: boolean;
+    setOpen?(state: boolean): void;
+    optionKey: K;
+    optionValue: K;
+    options: T[];
+    optionElement(props: IOptionProps<T, K>): React.ReactNode;
+    referenceElement(props: IReferenceProps<T, K>): React.ReactNode;
+}
+export declare const Dropdown: <T extends Record<string, any>, K extends keyof T>({ open, setOpen, options, optionKey, optionValue, ...props }: IProps<T, K>) => React.JSX.Element;
+export {};

package/types/components/symbols/dropdown/index.d.ts

@@ -0,0 +1 @@
+export { Dropdown } from './dropdown.tsx';

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

@@ -3,9 +3,11 @@ export * from './badge';
 export * from './button';
 export * from './button-icon';
 export * from './button-link';
+export * from './button-dropdown';
 export * from './radio';
 export * from './checkbox';
 export * from './input';
+export * from './input-select';
 export * from './textarea';
 export * from './label-field';
 export * from './caption-field';
@@ -22,3 +24,4 @@ export * from './quantity-stepper';
 export * from './breadcrumb';
 export * from './notification';
 export * from './modal';
+export * from './select';

package/types/components/symbols/input/input.d.ts

@@ -1,8 +1,8 @@
 import { default as React } from 'react';
-import { TIconName } from '../icon';
 export interface IProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size' | 'className'> {
-    leadicon?: TIconName;
-    tailicon?: TIconName;
+    ref?: React.RefCallback<HTMLInputElement>;
+    leadicon?: React.ReactNode;
+    tailicon?: React.ReactNode;
     badge?: string | number;
     size?: 'xs' | 'md';
     target?: 'destructive';

package/types/components/symbols/input-select/index.d.ts

@@ -0,0 +1 @@
+export { InputSelect } from './input-select.tsx';

package/types/components/symbols/input-select/input-select.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+export interface IProps<T extends Record<string, any>, K extends keyof T> extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size' | 'className' | 'children'> {
+    leadicon?: React.ReactNode;
+    tailicon?: React.ReactNode;
+    badge?: string | number;
+    size?: 'xs' | 'md';
+    target?: 'destructive';
+    optionKey: K;
+    optionValue: K;
+    options: T[];
+}
+export declare const InputSelect: <T extends Record<string, any>, K extends keyof T>({ options, optionKey, optionValue, ...props }: IProps<T, K>) => React.JSX.Element;

package/types/components/symbols/modal/modal.d.ts

@@ -25,13 +25,13 @@ export declare function useDialog({ initialOpen, open: controlledOpen, onOpen, o
         floating: HTMLElement | null;
     } & import('@floating-ui/react').ExtendedElements<import('@floating-ui/react').ReferenceType>;
     context: {
+        update: () => void;
         placement: import('@floating-ui/utils').Placement;
         strategy: import('@floating-ui/utils').Strategy;
         x: number;
         y: number;
         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;
@@ -72,13 +72,13 @@ export declare const useModalContext: () => {
         floating: HTMLElement | null;
     } & import('@floating-ui/react').ExtendedElements<import('@floating-ui/react').ReferenceType>;
     context: {
+        update: () => void;
         placement: import('@floating-ui/utils').Placement;
         strategy: import('@floating-ui/utils').Strategy;
         x: number;
         y: number;
         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;

package/types/components/symbols/select/index.d.ts

@@ -0,0 +1 @@
+export { Select } from './select.tsx';

package/types/components/symbols/select/input/index.d.ts

@@ -0,0 +1 @@
+export { Input } from './input.tsx';

package/types/components/symbols/select/input/input.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+export interface IProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size' | 'className'> {
+    ref?: React.RefCallback<HTMLInputElement>;
+    leadicon?: React.ReactNode;
+    tailicon?: React.ReactNode;
+    badge?: string | number;
+    size?: 'xs' | 'md';
+    target?: 'destructive';
+    isFocused?: boolean;
+}
+export declare const Input: React.FC<React.PropsWithChildren<IProps>>;

package/types/components/symbols/select/option/index.d.ts

@@ -0,0 +1 @@
+export { Option } from './option.tsx';

package/types/components/symbols/select/option/option.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+export interface IProps {
+    title: string;
+}
+export declare const Option: React.FC<IProps>;

package/types/components/symbols/select/select.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+export interface IProps<T extends Record<string, any>, K extends keyof T> extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size' | 'className' | 'children'> {
+    leadicon?: React.ReactNode;
+    tailicon?: React.ReactNode;
+    badge?: string | number;
+    size?: 'xs' | 'md';
+    target?: 'destructive';
+    optionKey: K;
+    optionValue: K;
+    options: T[];
+    value?: T[K];
+    templateValue?(option?: T): React.ReactNode;
+    templateOption?(option: T): React.ReactNode;
+}
+export declare const Select: <T extends Record<string, any>, K extends keyof T>({ value, options, optionKey, optionValue, templateValue, templateOption, ...props }: IProps<T, K>) => React.JSX.Element;