@pantograph/vue 0.22.6 → 0.23.1

package/dist/{ScrollContainer.vue_vue_type_style_index_0_lang-CSCDhOQB.js → ScrollContainer.vue_vue_type_style_index_0_lang-CZgFGbH_.js}

@@ -1,10 +1,10 @@
-import { defineComponent as q, createElementBlock as G, openBlock as v, normalizeClass as o, unref as e, createElementVNode as a, computed as oe, useTemplateRef as c, shallowRef as V, onBeforeUnmount as le, onMounted as re, createBlock as Y, mergeProps as F, withCtx as p, createVNode as f, createCommentVNode as W, renderSlot as I, Fragment as te } from "vue";
+import { defineComponent as q, createElementBlock as G, openBlock as p, normalizeClass as l, unref as e, createElementVNode as a, computed as le, ref as c, shallowRef as V, onBeforeUnmount as oe, onMounted as re, createBlock as F, mergeProps as T, withCtx as v, createVNode as f, createCommentVNode as W, renderSlot as I, Fragment as te } from "vue";
 import { ScrollAreaRoot as ae, ScrollAreaViewport as ie, ScrollAreaScrollbar as L, ScrollAreaThumb as U, ScrollAreaCorner as ne } from "reka-ui";
 import { cva as J } from "class-variance-authority";
 import { getBemBlock as ce, getBemElement as r, generateVariantClassList as i } from "@pantograph/utils";
-import { useElementVisibility as w, useIntersectionObserver as ue, useDebounceFn as fe, useResizeObserver as j } from "@vueuse/core";
-import { u as pe } from "./Icon.vue_vue_type_style_index_0_lang-m8dwDy4r.js";
-const l = ce("scroll_container"), ve = /* @__PURE__ */ q({
+import { useElementVisibility as k, useIntersectionObserver as ue, useDebounceFn as fe, useResizeObserver as j } from "@vueuse/core";
+import { u as ve } from "./Icon.vue_vue_type_style_index_0_lang-Kn_r4tp8.js";
+const o = ce("scroll_container"), pe = /* @__PURE__ */ q({
   __name: "Mask",
   props: {
     topVisible: { type: Boolean },
@@ -13,7 +13,7 @@ const l = ce("scroll_container"), ve = /* @__PURE__ */ q({
     startVisible: { type: Boolean }
   },
   setup(d) {
-    const m = d, t = r(l, "mask"), u = J(t, {
+    const b = d, t = r(o, "mask"), u = J(t, {
       variants: {
         topVisible: i("top-visible", t),
         bottomVisible: i("bottom-visible", t),
@@ -21,24 +21,24 @@ const l = ce("scroll_container"), ve = /* @__PURE__ */ q({
         endVisible: i("end-visible", t)
       }
     });
-    return (k, _) => (v(), G("div", {
-      class: o(e(u)(m))
+    return (w, _) => (p(), G("div", {
+      class: l(e(u)(b))
     }, [
       a("div", {
-        class: o(e(r)(e(t), "top"))
+        class: l(e(r)(e(t), "top"))
       }, null, 2),
       a("div", {
-        class: o(e(r)(e(t), "bottom"))
+        class: l(e(r)(e(t), "bottom"))
       }, null, 2),
       a("div", {
-        class: o(e(r)(e(t), "start"))
+        class: l(e(r)(e(t), "start"))
       }, null, 2),
       a("div", {
-        class: o(e(r)(e(t), "end"))
+        class: l(e(r)(e(t), "end"))
       }, null, 2)
     ], 2));
   }
-}), we = ["auto", "always", "scroll", "hover"], de = ["sm", "md", "lg"], ke = /* @__PURE__ */ q({
+}), ke = ["auto", "always", "scroll", "hover"], de = ["sm", "md", "lg"], we = /* @__PURE__ */ q({
   inheritAttrs: !1,
   __name: "ScrollContainer",
   props: {
@@ -59,27 +59,27 @@ const l = ce("scroll_container"), ve = /* @__PURE__ */ q({
     color: {}
   },
   emits: ["loadMore"],
-  setup(d, { expose: m, emit: t }) {
-    const u = d, k = t, _ = J(l, {
+  setup(d, { expose: b, emit: t }) {
+    const u = d, w = t, _ = J(o, {
       variants: {
-        size: i(de, l),
-        overlay: i("overlay", l),
-        isOverflowX: i("overflowed-x", l),
-        isOverflowY: i("overflowed-y", l),
-        hasMask: i("has-mask", l)
+        size: i(de, o),
+        overlay: i("overlay", o),
+        isOverflowX: i("overflowed-x", o),
+        isOverflowY: i("overflowed-y", o),
+        hasMask: i("has-mask", o)
       }
-    }), b = r(l, "scroll_bar"), B = r(b, "thumb"), { config: K } = pe(), Q = oe(() => u.dir ? u.dir : K.dir.value), S = c("top"), Z = w(S), g = c("end"), x = w(g), z = c("start"), ee = w(z), M = c("bottom"), y = V(!1), { stop: se } = ue(M, ([{ isIntersecting: s }]) => {
-      s ? (k("loadMore"), y.value = !0) : y.value = !1;
+    }), m = r(o, "scroll_bar"), B = r(m, "thumb"), { config: K } = ve(), Q = le(() => u.dir ? u.dir : K.dir.value), S = c(), Z = k(S), g = c(), x = k(g), z = c(), ee = k(z), M = c(), y = V(!1), { stop: se } = ue(M, ([{ isIntersecting: s }]) => {
+      s ? (w("loadMore"), y.value = !0) : y.value = !1;
     });
-    le(se);
-    const n = c("root"), O = c("container"), A = c("wrap"), D = V(!1), H = V(!1), h = fe(() => {
-      var s, C, R, E, P, $, N, T, X;
-      e((s = n.value) == null ? void 0 : s.viewport) && (D.value = (((R = (C = e(n.value)) == null ? void 0 : C.viewport) == null ? void 0 : R.offsetWidth) || 0) < (((P = (E = e(n.value)) == null ? void 0 : E.viewport) == null ? void 0 : P.scrollWidth) || 0), H.value = (((N = ($ = e(n.value)) == null ? void 0 : $.viewport) == null ? void 0 : N.offsetHeight) || 0) < (((X = (T = e(n.value)) == null ? void 0 : T.viewport) == null ? void 0 : X.scrollHeight) || 0));
+    oe(se);
+    const n = c(), O = c(), A = c(), D = V(!1), H = V(!1), h = fe(() => {
+      var s, C, E, P, R, $, N, X, Y;
+      e((s = n.value) == null ? void 0 : s.viewport) && (D.value = (((E = (C = e(n.value)) == null ? void 0 : C.viewport) == null ? void 0 : E.offsetWidth) || 0) < (((R = (P = e(n.value)) == null ? void 0 : P.viewport) == null ? void 0 : R.scrollWidth) || 0), H.value = (((N = ($ = e(n.value)) == null ? void 0 : $.viewport) == null ? void 0 : N.offsetHeight) || 0) < (((Y = (X = e(n.value)) == null ? void 0 : X.viewport) == null ? void 0 : Y.scrollHeight) || 0));
     }, 10);
-    return re(() => h()), j(n, h), j(A, h), m({
+    return re(() => h()), j(n, h), j(A, h), b({
       container: O,
       root: n
-    }), (s, C) => (v(), Y(e(ae), F({
+    }), (s, C) => (p(), F(e(ae), T({
       class: [
         e(_)({
           overlay: s.overlay,
@@ -100,48 +100,48 @@ const l = ce("scroll_container"), ve = /* @__PURE__ */ q({
       ref_key: "root",
       ref: n
     }), {
-      default: p(() => [
-        f(e(ie), F({
-          class: [e(r)(e(l), "area"), s.areaCls]
+      default: v(() => [
+        f(e(ie), T({
+          class: [e(r)(e(o), "area"), s.areaCls]
         }, s.$attrs, {
           ref_key: "container",
           ref: O,
           "as-child": ""
         }), {
-          default: p(() => [
+          default: v(() => [
             a("div", {
-              class: o([e(r)(e(l), "area__wrap"), s.wrapCls]),
+              class: l([e(r)(e(o), "area__wrap"), s.wrapCls]),
               ref_key: "wrap",
               ref: A
             }, [
               I(s.$slots, "default"),
-              s.hasMask ? (v(), G(te, { key: 0 }, [
+              s.hasMask ? (p(), G(te, { key: 0 }, [
                 a("div", {
                   ref_key: "top",
                   ref: S,
-                  class: o(e(r)(e(l), "top_observer"))
+                  class: l(e(r)(e(o), "top_observer"))
                 }, null, 2),
                 a("div", {
                   ref_key: "end",
                   ref: g,
-                  class: o(e(r)(e(l), "end_observer"))
+                  class: l(e(r)(e(o), "end_observer"))
                 }, null, 2),
                 a("div", {
                   ref_key: "start",
                   ref: z,
-                  class: o(e(r)(e(l), "start_observer"))
+                  class: l(e(r)(e(o), "start_observer"))
                 }, null, 2),
                 a("div", {
                   ref_key: "bottom",
                   ref: M,
-                  class: o(e(r)(e(l), "bottom_observer"))
+                  class: l(e(r)(e(o), "bottom_observer"))
                 }, null, 2)
               ], 64)) : W("", !0)
             ], 2)
           ]),
           _: 3
         }, 16, ["class"]),
-        s.hasMask ? (v(), Y(ve, {
+        s.hasMask ? (p(), F(pe, {
           key: 0,
           topVisible: e(Z),
           bottomVisible: y.value,
@@ -149,32 +149,32 @@ const l = ce("scroll_container"), ve = /* @__PURE__ */ q({
           startVisible: e(ee)
         }, null, 8, ["topVisible", "bottomVisible", "endVisible", "startVisible"])) : W("", !0),
         f(e(L), {
-          class: o([e(b), s.scrollbarCls]),
+          class: l([e(m), s.scrollbarCls]),
           orientation: "vertical",
           ref: "vertical"
         }, {
-          default: p(() => [
+          default: v(() => [
             f(e(U), {
-              class: o([e(B), s.thumbCls])
+              class: l([e(B), s.thumbCls])
             }, null, 8, ["class"])
           ]),
           _: 1
         }, 8, ["class"]),
         f(e(L), {
-          class: o([e(b), s.scrollbarCls]),
+          class: l([e(m), s.scrollbarCls]),
           orientation: "horizontal",
           ref: "horizontal"
         }, {
-          default: p(() => [
+          default: v(() => [
             f(e(U), {
-              class: o([e(B), s.thumbCls])
+              class: l([e(B), s.thumbCls])
             }, null, 8, ["class"])
           ]),
           _: 1
         }, 8, ["class"]),
         f(e(ne), {
           ref: "corner",
-          class: o(s.cornerCls)
+          class: l(s.cornerCls)
         }, null, 8, ["class"]),
         I(s.$slots, "root")
       ]),
@@ -183,7 +183,7 @@ const l = ce("scroll_container"), ve = /* @__PURE__ */ q({
   }
 });
 export {
-  we as S,
-  ke as _,
+  ke as S,
+  we as _,
   de as a
 };

package/dist/Select/Select.d.ts

@@ -0,0 +1,55 @@
+import { SelectProps, SelectSlots } from './types';
+declare function __VLS_template(): {
+    slots: Readonly<SelectSlots> & SelectSlots;
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SelectProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: import('reka-ui', { with: { "resolution-mode": "import" } }).AcceptableValue) => any;
+    closeAutoFocus: (event: Event) => any;
+    "update:open": (value: boolean) => any;
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    pointerDownOutside: (event: CustomEvent<{
+        originalEvent: PointerEvent;
+    }>) => any;
+}, string, import('vue').PublicProps, Readonly<SelectProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import('reka-ui', { with: { "resolution-mode": "import" } }).AcceptableValue) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: CustomEvent<{
+        originalEvent: PointerEvent;
+    }>) => any) | undefined;
+}>, {
+    size: import('./Select.model.ts', { with: { "resolution-mode": "import" } }).SelectSize;
+    disabled: boolean;
+    placement: import('../index.ts', { with: { "resolution-mode": "import" } }).PopoverPlacement;
+    forceMount: boolean;
+    prioritizePosition: boolean;
+    sideOffset: number;
+    avoidCollisions: boolean;
+    collisionPadding: number | Partial<Record<"top" | "bottom" | "right" | "left", number>>;
+    disableUpdateOnLayoutShift: boolean;
+    hideWhenDetached: boolean;
+    positionStrategy: "absolute" | "fixed";
+    defaultOpen: boolean;
+    open: boolean;
+    trailingIcon: string;
+    bordered: boolean;
+    multiple: boolean;
+    loadingRowCount: number;
+    position: "item-aligned" | "popper";
+    selectedItemIconAsTrailingIcon: boolean;
+    indicatorIcon: string;
+    clearOnChangeMultiple: boolean;
+    samePopupWidth: boolean;
+    popupHeight: string | number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Select/Select.model.d.ts

@@ -0,0 +1,4 @@
+export declare const SelectSizes: readonly ["sm", "md", "lg"];
+export type SelectSize = (typeof SelectSizes)[number];
+export declare const SelectStatuses: readonly ["error", "warning", "success"];
+export type SelectStatus = (typeof SelectStatuses)[number];

package/dist/Select/SelectLabel.d.ts

@@ -0,0 +1,16 @@
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Select/SelectOption.d.ts

@@ -0,0 +1,19 @@
+import { SlotsType } from 'vue';
+import { SelectOptionItem, SelectOptionSlots } from './types';
+export interface SelectOptionProps {
+    option: SelectOptionItem;
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    option: {
+        type: () => SelectOptionItem;
+        required: true;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    option: {
+        type: () => SelectOptionItem;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, SlotsType<SelectOptionSlots>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/Select/SelectTrigger.d.ts

@@ -0,0 +1,11 @@
+import { CheckNode } from '../utils';
+import { SelectOptionSlotsKeys } from './types';
+type GetOptionSlot = (name: SelectOptionSlotsKeys, value?: string) => (() => CheckNode[] | undefined) | undefined;
+declare const _default: import('vue').DefineComponent<{
+    getOptionSlot: GetOptionSlot;
+}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    getOptionSlot: GetOptionSlot;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/Select/SelectWrapper.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/Select/context.d.ts

@@ -0,0 +1,28 @@
+import { SelectEmitObject, SelectOptionType, SelectOptionItem, SelectProps } from './types';
+import { injectSelectRootContext } from 'reka-ui';
+import { ComputedRef, Ref } from 'vue';
+import { SelectSize, SelectStatus } from './Select.model';
+export type SelectRootContext = Exclude<ReturnType<typeof injectSelectRootContext>, undefined | null>;
+export interface _SelectContext {
+    props: SelectProps;
+    attrs: Record<string, any>;
+    emitsAsProps: SelectEmitObject;
+    emit: any;
+}
+export interface SelectContext extends SelectRootContext, Omit<_SelectContext, 'emitsAsProps'> {
+    modelValue: Ref<string | string[] | undefined>;
+    getOptionValue: (option?: SelectOptionItem) => string | undefined;
+    getOptionLabel: (option?: SelectOptionItem) => string | undefined;
+    getOptionDisabled: (option?: SelectOptionItem) => boolean | undefined;
+    getOptionIcon: (option?: SelectOptionItem) => string | undefined;
+    getOptionGroupLabel: (option?: SelectOptionItem) => string | undefined;
+    getOptionGroupOptions: (option?: SelectOptionType) => SelectOptionItem[] | undefined;
+    getOptionByValue: (value: string) => SelectOptionItem | undefined;
+    getLabelByValue: (value: string) => string | undefined;
+    getDisabled: ComputedRef<boolean>;
+    getStatus: ComputedRef<SelectStatus>;
+    getSize: ComputedRef<SelectSize>;
+}
+export declare const injectSelectContext: <T extends SelectContext | null | undefined = SelectContext>(fallback?: T | undefined) => T extends null ? SelectContext | null : SelectContext, provideSelectContext: (contextValue: SelectContext) => SelectContext;
+export declare const _injectSelectContext: <T extends _SelectContext | null | undefined = _SelectContext>(fallback?: T | undefined) => T extends null ? _SelectContext | null : _SelectContext, _provideSelectContext: (contextValue: _SelectContext) => _SelectContext;
+export declare const selectPrefix: string;

package/dist/Select/index.d.ts

@@ -0,0 +1,6 @@
+export { default as Select } from './Select';
+export { default as SelectOption, type SelectOptionProps } from './SelectOption';
+export { default as SelectLabel } from './SelectLabel';
+export { type SelectSize, type SelectStatus, SelectSizes, SelectStatuses } from './Select.model';
+export type { SelectSlots, SelectProps, SelectEmits, SelectOptionType } from './types';
+export { provideSelectContext, injectSelectContext, type SelectContext } from './context';

package/dist/Select/index.js

@@ -0,0 +1,10 @@
+import { _ as a, a as s, S, b as c, c as l, i as o, p as i } from "../Select.vue_vue_type_style_index_0_lang-ClYkFAEj.js";
+export {
+  a as Select,
+  s as SelectLabel,
+  S as SelectOption,
+  c as SelectSizes,
+  l as SelectStatuses,
+  o as injectSelectContext,
+  i as provideSelectContext
+};

package/dist/Select/index.umd.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("../Select.vue_vue_type_style_index_0_lang-RdNEKYeJ.js");exports.Select=e._sfc_main;exports.SelectLabel=e._sfc_main$1;exports.SelectOption=e.SelectOption;exports.SelectSizes=e.SelectSizes;exports.SelectStatuses=e.SelectStatuses;exports.injectSelectContext=e.injectSelectContext;exports.provideSelectContext=e.provideSelectContext;

package/dist/Select/types.d.ts

@@ -0,0 +1,126 @@
+import { SelectContentEmits, SelectContentProps, SelectPortalProps, SelectRootEmits, SelectRootProps, SelectTriggerProps } from 'reka-ui';
+import { GetPopupContainer } from '../Popover/Popover';
+import { PopoverPlacement } from '../Popover';
+import { Direction } from '../ConfigProvider';
+import { SkeletonProps } from '../Skeleton/Skeleton';
+import { SelectSize, SelectStatus } from './Select.model';
+import { Class, EmitToProp } from '../types';
+import { ScrollContainerProps } from '../ScrollContainer/index.js';
+import { EmptyProps } from '../Empty/index.js';
+export interface SelectOptionItemDefault {
+    icon?: string;
+    label?: string;
+    value: string;
+    disabled?: boolean;
+}
+export type SelectOptionItem = SelectOptionItemDefault | object | string;
+interface SelectOptionGroup {
+    label?: string;
+    options: SelectOptionItem[];
+}
+export type SelectOptionType = SelectOptionItem | SelectOptionGroup;
+export type selectOptionGetter<T = string> = string | number | ((option: object) => T | undefined);
+export interface SelectProps extends SelectRootProps, Omit<SelectTriggerProps, 'as' | 'asChild'>, SelectContentProps, Omit<SelectPortalProps, 'to'> {
+    status?: SelectStatus;
+    size?: SelectSize;
+    multiple?: boolean;
+    contentFit?: boolean;
+    wrapped?: boolean;
+    noTrailing?: boolean;
+    leadingIcon?: string;
+    trailingIcon?: string;
+    selectedItemIconAsTrailingIcon?: boolean;
+    maxCount?: number | string;
+    to?: string | HTMLElement | GetPopupContainer;
+    placeholder?: string;
+    indicatorIcon?: string;
+    options?: SelectOptionType[];
+    getDisabled?: selectOptionGetter<boolean>;
+    getLabel?: selectOptionGetter;
+    getValue?: selectOptionGetter;
+    getGroupOptions?: selectOptionGetter<SelectOptionItem[]>;
+    getGroupLabel?: selectOptionGetter;
+    getIcon?: selectOptionGetter;
+    placement?: PopoverPlacement;
+    reversePlacementOnDir?: Direction;
+    loading?: boolean;
+    skeletonProps?: SkeletonProps;
+    loadingRowCount?: number;
+    lazyLoading?: boolean;
+    bordered?: boolean;
+    clearOnChangeMultiple?: boolean;
+    triggerCls?: Class;
+    triggerLeadingCls?: Class;
+    triggerContentCls?: Class;
+    triggerContentPlaceholderCls?: Class;
+    triggerContentValueCls?: Class;
+    triggerTrailingCls?: Class;
+    itemLeadingCls?: Class;
+    optionCls?: Class;
+    tagListCls?: Class;
+    tagCls?: Class;
+    popupCls?: Class;
+    labelCls?: Class;
+    optionsCls?: Class;
+    optionTextCls?: Class;
+    optionContentCls?: Class;
+    emptyCls?: Class;
+    skeletonCls?: Class;
+    scrollContainerProps?: ScrollContainerProps;
+    emptyProps?: EmptyProps;
+    samePopupWidth?: boolean;
+    popupHeight?: string | number;
+    popupWidth?: string | number;
+    minWidth?: string | number;
+}
+export interface SelectEmits extends SelectRootEmits, SelectContentEmits {
+}
+export type SelectEmitObject = {
+    [K in keyof SelectEmits as EmitToProp<K>]: () => void;
+};
+export type SelectRootEmitObject = {
+    [K in keyof SelectEmits as EmitToProp<K>]: () => void;
+};
+export interface SelectItemSlotProps {
+    option: SelectOptionItem;
+}
+export interface SelectOptionSlots {
+    default?: (data: SelectItemSlotProps) => never;
+    leading?: (data: SelectItemSlotProps) => never;
+    text?: (data: SelectItemSlotProps) => never;
+    indicator?: (data: SelectItemSlotProps) => never;
+}
+export type SelectOptionSlotsKeys = keyof SelectOptionSlots;
+interface SelectTriggerDefSlotProps {
+    modelValue: string | string[] | undefined;
+    open: boolean;
+}
+interface SelectTriggerTagSlotProps extends SelectTriggerDefSlotProps {
+    option: SelectOptionItem;
+}
+export interface SelectTriggerSlots {
+    triggerLeading?: (data: SelectTriggerDefSlotProps) => never;
+    placeholder?: (data: SelectTriggerDefSlotProps) => never;
+    triggerValue?: (data: SelectTriggerDefSlotProps) => never;
+    triggerTrailing?: (data: SelectTriggerDefSlotProps) => never;
+    tagClose?: (data: SelectTriggerTagSlotProps & {
+        onClose: (e: MouseEvent) => void;
+    }) => never;
+    tagTrailing?: (data: SelectTriggerTagSlotProps) => never;
+    tagLeading?: (data: SelectTriggerTagSlotProps) => never;
+    tagText?: (data: SelectTriggerTagSlotProps) => never;
+}
+export interface SelectSlots extends SelectTriggerSlots {
+    default?: (data?: object) => never;
+    empty?: (data?: object) => never;
+    loading?: (data?: object) => never;
+    emptyTitle?: (data?: object) => never;
+    emptyDescription?: (data?: object) => never;
+    emptyActions?: (data?: object) => never;
+    emptyImage?: (data?: object) => never;
+    option?: (data: SelectItemSlotProps) => never;
+    optionLeading?: (data: SelectItemSlotProps) => never;
+    optionText?: (data: SelectItemSlotProps) => never;
+    optionIndicator?: (data: SelectItemSlotProps) => never;
+}
+export {};