@raxium/vue 0.1.0 → 0.1.1

package/dist/components/date-picker/DatePickerYearView.js

@@ -0,0 +1,139 @@
+import { Fragment, computed, createBlock, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, mergeProps, normalizeClass, openBlock, renderList, toDisplayString, unref, withCtx } from "vue";
+import { DatePicker, useDatePickerContext } from "@ark-ui/vue";
+import { clsx } from "@raxium/themes/utils";
+import { useTheme } from "../../composables/useTheme.js";
+import { flatten } from "es-toolkit";
+import { ChevronLeft, ChevronRight } from "lucide-vue-next";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    __name: "DatePickerYearView",
+    props: {
+        class: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        theme: {}
+    },
+    setup (__props) {
+        const context = useDatePickerContext();
+        const theme = useTheme(()=>Object.assign({}, __props.theme, {
+                view: "year"
+            }));
+        const crafts = computed(()=>theme.value.crafts.tvDatePickerView());
+        return (_ctx, _cache)=>(openBlock(), createBlock(unref(DatePicker).View, {
+                view: "year",
+                class: normalizeClass(crafts.value.view({
+                    class: unref(clsx)(__props.class),
+                    ...unref(theme)
+                }))
+            }, {
+                default: withCtx(()=>[
+                        createVNode(unref(DatePicker).ViewControl, {
+                            class: normalizeClass(crafts.value.viewControl({
+                                ...unref(theme)
+                            }))
+                        }, {
+                            default: withCtx(()=>[
+                                    createVNode(unref(DatePicker).PrevTrigger, {
+                                        "as-child": "",
+                                        class: normalizeClass(crafts.value.viewControlTrigger({
+                                            ...unref(theme)
+                                        }))
+                                    }, {
+                                        default: withCtx(()=>[
+                                                createVNode(unref(ChevronLeft), {
+                                                    style: {
+                                                        width: "1lh",
+                                                        height: "1lh"
+                                                    }
+                                                })
+                                            ]),
+                                        _: 1
+                                    }, 8, [
+                                        "class"
+                                    ]),
+                                    createVNode(unref(DatePicker).RangeText),
+                                    createVNode(unref(DatePicker).NextTrigger, {
+                                        "as-child": "",
+                                        class: normalizeClass(crafts.value.viewControlTrigger({
+                                            ...unref(theme)
+                                        }))
+                                    }, {
+                                        default: withCtx(()=>[
+                                                createVNode(unref(ChevronRight), {
+                                                    style: {
+                                                        width: "1lh",
+                                                        height: "1lh"
+                                                    }
+                                                })
+                                            ]),
+                                        _: 1
+                                    }, 8, [
+                                        "class"
+                                    ])
+                                ]),
+                            _: 1
+                        }, 8, [
+                            "class"
+                        ]),
+                        createVNode(unref(DatePicker).Table, {
+                            class: normalizeClass(crafts.value.table({
+                                ...unref(theme)
+                            }))
+                        }, {
+                            default: withCtx(()=>[
+                                    createElementVNode("div", mergeProps(unref(context).getTableBodyProps(), {
+                                        class: crafts.value.tableBody({
+                                            ...unref(theme)
+                                        })
+                                    }), [
+                                        (openBlock(true), createElementBlock(Fragment, null, renderList(unref(flatten)(unref(context).getYearsGrid({
+                                            columns: 4
+                                        })), (year, yid)=>(openBlock(), createBlock(unref(DatePicker).TableCell, {
+                                                key: `year-${yid}`,
+                                                value: year.value,
+                                                class: normalizeClass(crafts.value.tableCell({
+                                                    ...unref(theme)
+                                                }))
+                                            }, {
+                                                default: withCtx(()=>[
+                                                        createVNode(unref(DatePicker).TableCellTrigger, {
+                                                            class: normalizeClass(crafts.value.tableCellTrigger({
+                                                                ...unref(context).getYearTableCellState({
+                                                                    value: year.value
+                                                                }),
+                                                                ...unref(theme)
+                                                            }))
+                                                        }, {
+                                                            default: withCtx(()=>[
+                                                                    createTextVNode(toDisplayString(year.label), 1)
+                                                                ]),
+                                                            _: 2
+                                                        }, 1032, [
+                                                            "class"
+                                                        ])
+                                                    ]),
+                                                _: 2
+                                            }, 1032, [
+                                                "value",
+                                                "class"
+                                            ]))), 128))
+                                    ], 16)
+                                ]),
+                            _: 1
+                        }, 8, [
+                            "class"
+                        ])
+                    ]),
+                _: 1
+            }, 8, [
+                "class"
+            ]));
+    }
+});
+const DatePickerYearView = _sfc_main;
+export default DatePickerYearView;

package/dist/components/date-picker/DatePickerYearView.vue.d.ts

@@ -0,0 +1,4 @@
+import type { DatePickerYearViewProps } from '.';
+declare const __VLS_export: import("vue").DefineComponent<DatePickerYearViewProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DatePickerYearViewProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/date-picker/index.d.ts

@@ -0,0 +1,8 @@
+export { default as DatePicker } from './DatePicker.vue';
+export { default as DatePickerContent } from './DatePickerContent.vue';
+export { default as DatePickerControl } from './DatePickerControl.vue';
+export { default as DatePickerDayView } from './DatePickerDayView.vue';
+export { default as DatePickerMonthView } from './DatePickerMonthView.vue';
+export { default as DatePickerYearView } from './DatePickerYearView.vue';
+export * from './props';
+export { DatePickerTrigger, DatePickerValueText } from '@ark-ui/vue/date-picker';

package/dist/components/date-picker/index.js

@@ -0,0 +1,8 @@
+export * from "./props.js";
+export { default as DatePicker } from "./DatePicker.js";
+export { default as DatePickerContent } from "./DatePickerContent.js";
+export { default as DatePickerControl } from "./DatePickerControl.js";
+export { default as DatePickerDayView } from "./DatePickerDayView.js";
+export { default as DatePickerMonthView } from "./DatePickerMonthView.js";
+export { default as DatePickerYearView } from "./DatePickerYearView.js";
+export { DatePickerTrigger, DatePickerValueText } from "@ark-ui/vue/date-picker";

package/dist/components/date-picker/props.d.ts

@@ -0,0 +1,42 @@
+import type { DatePickerContentBaseProps, DatePickerControlBaseProps, DatePickerRootBaseProps } from '@ark-ui/vue';
+import type { ThemeCrafts, ThemeNoCrafts } from '../../providers';
+import type * as ZagDatePicker from '@zag-js/date-picker';
+import type { ComputedRef, HTMLAttributes } from 'vue';
+export type DatePickerContentProvide = {
+    viewsState: ComputedRef<{
+        count: number;
+        hasDayView: boolean;
+        hasMonthView: boolean;
+        hasYearView: boolean;
+    }>;
+};
+export declare const DATE_PICKER_CONTENT_PROVIDE_KEY: unique symbol;
+export interface DatePickerProps extends DatePickerRootBaseProps, ThemeCrafts<'tvDatePicker'> {
+}
+export type DatePickerRootEmits = {
+    'focusChange': [details: ZagDatePicker.FocusChangeDetails];
+    'openChange': [details: ZagDatePicker.OpenChangeDetails];
+    'valueChange': [details: ZagDatePicker.ValueChangeDetails];
+    'viewChange': [details: ZagDatePicker.ViewChangeDetails];
+    'update:modelValue': [value: ZagDatePicker.DateValue[]];
+    'update:open': [open: boolean];
+    'update:view': [view: ZagDatePicker.DateView];
+    'update:focusedValue': [focusedValue: ZagDatePicker.DateValue];
+};
+export interface DatePickerContentProps extends DatePickerContentBaseProps, ThemeNoCrafts {
+    class?: HTMLAttributes['class'];
+}
+export interface DatePickerControlProps extends DatePickerControlBaseProps, ThemeNoCrafts {
+    class?: HTMLAttributes['class'];
+}
+export interface DatePickerDayViewProps extends ThemeNoCrafts {
+    class?: HTMLAttributes['class'];
+    weekDayType?: 'short' | 'long' | 'narrow';
+}
+export interface DatePickerMonthViewProps extends ThemeNoCrafts {
+    class?: HTMLAttributes['class'];
+    monthType?: 'short' | 'long';
+}
+export interface DatePickerYearViewProps extends ThemeNoCrafts {
+    class?: HTMLAttributes['class'];
+}

package/dist/components/date-picker/props.js

@@ -0,0 +1,2 @@
+const DATE_PICKER_CONTENT_PROVIDE_KEY = Symbol('DATE_PICKER_CONTENT_PROVIDE_KEY');
+export { DATE_PICKER_CONTENT_PROVIDE_KEY };

package/dist/components/dialog/Dialog.js

@@ -0,0 +1,190 @@
+import { computed, createBlock, createPropsRestProxy, createVNode, defineComponent, nextTick, openBlock, ref, renderSlot, unref, watch, withCtx } from "vue";
+import { useForwardExpose, useForwardProps } from "@ark-ui/vue";
+import { Dialog, useDialog } from "@ark-ui/vue/dialog";
+import { useConfig } from "../../composables/useConfig.js";
+import { useTheme } from "../../composables/useTheme.js";
+import { ThemeProvider } from "../../providers/theme/index.js";
+import { TriggerFrom } from "./dialog-intercept-context.js";
+import DialogInterceptProvider from "./DialogInterceptProvider.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    __name: "Dialog",
+    props: {
+        class: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        "aria-label": {},
+        closeOnEscape: {
+            type: Boolean
+        },
+        closeOnInteractOutside: {
+            type: Boolean
+        },
+        defaultOpen: {
+            type: Boolean
+        },
+        finalFocusEl: {
+            type: Function
+        },
+        id: {},
+        ids: {},
+        initialFocusEl: {
+            type: Function
+        },
+        modal: {
+            type: Boolean
+        },
+        open: {
+            type: Boolean
+        },
+        persistentElements: {},
+        preventScroll: {
+            type: Boolean
+        },
+        restoreFocus: {
+            type: Boolean
+        },
+        role: {},
+        trapFocus: {
+            type: Boolean
+        },
+        lazyMount: {
+            type: Boolean,
+            default: ()=>void 0
+        },
+        unmountOnExit: {
+            type: Boolean,
+            default: ()=>void 0
+        },
+        theme: {}
+    },
+    emits: [
+        "update:open",
+        "openChange",
+        "escapeKeyDown",
+        "focusOutside",
+        "interactOutside",
+        "pointerDownOutside",
+        "requestDismiss",
+        "exitComplete"
+    ],
+    setup (__props, { expose: __expose, emit: __emit }) {
+        const props = createPropsRestProxy(__props, [
+            "class",
+            "theme",
+            "lazyMount",
+            "unmountOnExit"
+        ]);
+        const emits = __emit;
+        const dialogConfig = useConfig("dialog", computed(()=>({
+                lazyMount: __props.lazyMount,
+                unmountOnExit: __props.unmountOnExit
+            })));
+        const forwarded = useForwardProps(props);
+        const triggerFrom = ref(void 0);
+        const dialogInterceptContext = {
+            triggerFrom
+        };
+        const dialog = useDialog(computed(()=>({
+                ...forwarded.value,
+                onOpenChange: (details)=>{
+                    emits("openChange", {
+                        ...details,
+                        from: triggerFrom.value
+                    });
+                    emits("update:open", details.open);
+                    forwarded.value.onOpenChange?.({
+                        ...details,
+                        from: triggerFrom.value
+                    });
+                },
+                onEscapeKeyDown: (event)=>{
+                    triggerFrom.value = TriggerFrom.ESCAPE;
+                    emits("escapeKeyDown", event);
+                    forwarded.value.onEscapeKeyDown?.(event);
+                },
+                onFocusOutside: (event)=>{
+                    emits("focusOutside", event);
+                    forwarded.value.onFocusOutside?.(event);
+                },
+                onInteractOutside: (event)=>{
+                    triggerFrom.value = TriggerFrom.OUTSIDE;
+                    emits("interactOutside", event);
+                    forwarded.value.onInteractOutside?.(event);
+                },
+                onPointerDownOutside: (event)=>{
+                    emits("pointerDownOutside", event);
+                    forwarded.value.onPointerDownOutside?.(event);
+                },
+                onRequestDismiss: (event)=>{
+                    emits("requestDismiss", event);
+                    forwarded.value.onRequestDismiss?.(event);
+                }
+            })));
+        const initialized = ref(false);
+        watch(()=>[
+                forwarded.value.open,
+                forwarded.value.defaultOpen
+            ], async ([open, defaultOpen])=>{
+            if (!initialized.value) {
+                initialized.value = true;
+                await nextTick();
+                if (void 0 === open) dialog.value.setOpen(!!defaultOpen);
+                else dialog.value.setOpen(!!open);
+                return;
+            }
+            if (void 0 !== open) {
+                await nextTick();
+                dialog.value.setOpen(!!open);
+            }
+        }, {
+            immediate: true
+        });
+        const theme = useTheme(()=>__props.theme);
+        __expose({
+            $api: dialog
+        });
+        useForwardExpose();
+        return (_ctx, _cache)=>(openBlock(), createBlock(unref(Dialog).RootProvider, {
+                value: unref(dialog),
+                "lazy-mount": unref(dialogConfig)?.lazyMount ?? __props.lazyMount,
+                "unmount-on-exit": unref(dialogConfig)?.unmountOnExit ?? __props.unmountOnExit,
+                onExitComplete: _cache[0] || (_cache[0] = ()=>{
+                    unref(forwarded).onExitComplete?.();
+                    emits("exitComplete");
+                })
+            }, {
+                default: withCtx(()=>[
+                        createVNode(DialogInterceptProvider, {
+                            value: dialogInterceptContext
+                        }, {
+                            default: withCtx(()=>[
+                                    createVNode(unref(ThemeProvider), {
+                                        value: unref(theme)
+                                    }, {
+                                        default: withCtx(()=>[
+                                                renderSlot(_ctx.$slots, "default")
+                                            ]),
+                                        _: 3
+                                    }, 8, [
+                                        "value"
+                                    ])
+                                ]),
+                            _: 3
+                        })
+                    ]),
+                _: 3
+            }, 8, [
+                "value",
+                "lazy-mount",
+                "unmount-on-exit"
+            ]));
+    }
+});
+const dialog_Dialog = _sfc_main;
+export default dialog_Dialog;

package/dist/components/dialog/Dialog.vue.d.ts

@@ -0,0 +1,36 @@
+import type { UseDialogReturn } from '@ark-ui/vue/dialog';
+import type { DialogOpenChangeDetails, DialogProps } from '.';
+import type { FocusOutsideEvent, InteractOutsideEvent, PointerDownOutsideEvent, RequestDismissEvent } from './dialog-intercept-context';
+declare var __VLS_22: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_22) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<DialogProps, {
+    $api: UseDialogReturn;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    openChange: (details: DialogOpenChangeDetails) => any;
+    exitComplete: () => any;
+    "update:open": (open: boolean) => any;
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    focusOutside: (event: FocusOutsideEvent) => any;
+    interactOutside: (event: InteractOutsideEvent) => any;
+    pointerDownOutside: (event: PointerDownOutsideEvent) => any;
+    requestDismiss: (event: RequestDismissEvent) => any;
+}, string, import("vue").PublicProps, Readonly<DialogProps> & Readonly<{
+    onOpenChange?: ((details: DialogOpenChangeDetails) => any) | undefined;
+    onExitComplete?: (() => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: InteractOutsideEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
+    onRequestDismiss?: ((event: RequestDismissEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/dialog/DialogBackdrop.js

@@ -0,0 +1,54 @@
+import { computed, createBlock, createCommentVNode, defineComponent, mergeProps, openBlock, renderSlot, unref, withCtx } from "vue";
+import { useForwardExpose, usePresenceContext } from "@ark-ui/vue";
+import { useDialogContext } from "@ark-ui/vue/dialog";
+import { ark } from "@ark-ui/vue/factory";
+import { clsx } from "@raxium/themes/utils";
+import { useTheme } from "../../composables/useTheme.js";
+import { merge, omit } from "es-toolkit";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    __name: "DialogBackdrop",
+    props: {
+        class: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        asChild: {
+            type: Boolean
+        },
+        theme: {}
+    },
+    setup (__props) {
+        const dialog = useDialogContext();
+        const presence = usePresenceContext();
+        const mergedProps = computed(()=>merge(dialog.value.getBackdropProps(), omit(presence.value.presenceProps, [
+                "ref"
+            ])));
+        const theme = useTheme(()=>__props.theme);
+        const crafts = computed(()=>theme.value.crafts.tvDialog());
+        useForwardExpose();
+        return (_ctx, _cache)=>unref(presence).unmounted ? createCommentVNode("", true) : (openBlock(), createBlock(unref(ark).div, mergeProps({
+                key: 0
+            }, mergedProps.value, {
+                class: crafts.value.backdrop({
+                    class: unref(clsx)(__props.class),
+                    ...unref(theme)
+                }),
+                "as-child": __props.asChild
+            }), {
+                default: withCtx(()=>[
+                        renderSlot(_ctx.$slots, "default")
+                    ]),
+                _: 3
+            }, 16, [
+                "class",
+                "as-child"
+            ]));
+    }
+});
+const DialogBackdrop = _sfc_main;
+export default DialogBackdrop;

package/dist/components/dialog/DialogBackdrop.vue.d.ts

@@ -0,0 +1,14 @@
+import type { DialogBackdropProps } from '.';
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<DialogBackdropProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DialogBackdropProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/dialog/DialogBody.js

@@ -0,0 +1,52 @@
+import { computed, createBlock, createPropsRestProxy, defineComponent, mergeProps, openBlock, renderSlot, unref, useId, withCtx } from "vue";
+import { useForwardProps } from "@ark-ui/vue";
+import { ark } from "@ark-ui/vue/factory";
+import { clsx } from "@raxium/themes/utils";
+import { useTheme } from "../../composables/useTheme.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    __name: "DialogBody",
+    props: {
+        class: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        asChild: {
+            type: Boolean
+        },
+        theme: {}
+    },
+    setup (__props) {
+        const props = createPropsRestProxy(__props, [
+            "class",
+            "theme"
+        ]);
+        const forwarded = useForwardProps(props);
+        const id = useId();
+        const theme = useTheme(()=>__props.theme);
+        const crafts = computed(()=>theme.value.crafts.tvDialog());
+        return (_ctx, _cache)=>(openBlock(), createBlock(unref(ark).div, mergeProps(unref(forwarded), {
+                id: `dialog:${unref(id)}:body`,
+                "data-scope": "dialog",
+                "data-part": "body",
+                class: crafts.value.body({
+                    class: unref(clsx)(__props.class),
+                    ...unref(theme)
+                })
+            }), {
+                default: withCtx(()=>[
+                        renderSlot(_ctx.$slots, "default")
+                    ]),
+                _: 3
+            }, 16, [
+                "id",
+                "class"
+            ]));
+    }
+});
+const DialogBody = _sfc_main;
+export default DialogBody;

package/dist/components/dialog/DialogBody.vue.d.ts

@@ -0,0 +1,14 @@
+import type { DialogBodyProps } from '.';
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<DialogBodyProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DialogBodyProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/dialog/DialogCloseTrigger.js

@@ -0,0 +1,47 @@
+import { computed, createBlock, createPropsRestProxy, defineComponent, mergeProps, openBlock, renderSlot, unref, withCtx } from "vue";
+import { useForwardExpose, useForwardProps } from "@ark-ui/vue";
+import { useDialogContext } from "@ark-ui/vue/dialog";
+import { ark } from "@ark-ui/vue/factory";
+import { TriggerFrom, injectDialogInterceptContext } from "./dialog-intercept-context.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    __name: "DialogCloseTrigger",
+    props: {
+        from: {
+            default: ()=>TriggerFrom.CLOSE_TRIGGER
+        },
+        asChild: {
+            type: Boolean
+        }
+    },
+    setup (__props) {
+        const props = createPropsRestProxy(__props, [
+            "from",
+            "asChild"
+        ]);
+        const forwarded = useForwardProps(props);
+        const context = useDialogContext();
+        const interceptContext = injectDialogInterceptContext();
+        const triggerProps = computed(()=>{
+            const contextProps = context.value.getCloseTriggerProps();
+            return Object.assign({}, contextProps, forwarded.value, {
+                onClick: (e)=>{
+                    interceptContext.value.triggerFrom.value = __props.from;
+                    contextProps.onClick?.(e);
+                }
+            });
+        });
+        useForwardExpose();
+        return (_ctx, _cache)=>(openBlock(), createBlock(unref(ark).button, mergeProps(triggerProps.value, {
+                "as-child": __props.asChild
+            }), {
+                default: withCtx(()=>[
+                        renderSlot(_ctx.$slots, "default")
+                    ]),
+                _: 3
+            }, 16, [
+                "as-child"
+            ]));
+    }
+});
+const DialogCloseTrigger = _sfc_main;
+export default DialogCloseTrigger;

package/dist/components/dialog/DialogCloseTrigger.vue.d.ts

@@ -0,0 +1,14 @@
+import type { DialogCloseTriggerProps } from '.';
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<DialogCloseTriggerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DialogCloseTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};