@geniusdynamics/ns8-ui-lib 1.0.0

package/dist/src/App.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/components/HelloWorld.vue.d.ts

@@ -0,0 +1,5 @@
+type __VLS_Props = {
+    msg: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/components/NS/cards/NSBackupCard.vue.d.ts

@@ -0,0 +1,51 @@
+interface Backup {
+    id: string;
+    name: string;
+    date: string;
+    size: string;
+    enabled: boolean;
+    status?: 'success' | 'error' | 'running' | 'pending';
+}
+interface Status {
+    [key: string]: {
+        success?: boolean;
+        message?: string;
+    };
+}
+interface Props {
+    title?: string;
+    loading?: boolean;
+    backups?: Backup[];
+    status?: Status;
+    noBackupMessage?: string;
+    statusLabel?: string;
+    statusSuccessLabel?: string;
+    backupDisabledLabel?: string;
+    light?: boolean;
+    maxHeight?: string;
+    class?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    delete: (backupId: string) => any;
+    backup: (backupId: string) => any;
+    restore: (backupId: string) => any;
+    enable: (backupId: string) => any;
+    disable: (backupId: string) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onDelete?: ((backupId: string) => any) | undefined;
+    onBackup?: ((backupId: string) => any) | undefined;
+    onRestore?: ((backupId: string) => any) | undefined;
+    onEnable?: ((backupId: string) => any) | undefined;
+    onDisable?: ((backupId: string) => any) | undefined;
+}>, {
+    title: string;
+    status: Status;
+    loading: boolean;
+    backups: Backup[];
+    noBackupMessage: string;
+    statusLabel: string;
+    statusSuccessLabel: string;
+    backupDisabledLabel: string;
+    light: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/components/NS/cards/NSSystemInfoCard.vue.d.ts

@@ -0,0 +1,58 @@
+interface SystemMetrics {
+    totalSpace: string;
+    usedSpace: string;
+    freeSpace: string;
+    usagePercentage: number;
+    temperature?: string;
+    loadAverage?: string[];
+    uptime?: string;
+    processes?: number;
+    memory?: {
+        total: string;
+        used: string;
+        free: string;
+        percentage: number;
+    };
+    cpu?: {
+        cores: number;
+        usage: number;
+        frequency: string;
+    };
+}
+interface Props {
+    title?: string;
+    description?: string;
+    metrics?: SystemMetrics;
+    loading?: boolean;
+    refreshInterval?: number;
+    showTemperature?: boolean;
+    showLoadAverage?: boolean;
+    showUptime?: boolean;
+    showProcesses?: boolean;
+    showMemory?: boolean;
+    showCpu?: boolean;
+    showStorage?: boolean;
+    refreshable?: boolean;
+    light?: boolean;
+    maxHeight?: string;
+    class?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    refresh: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onRefresh?: (() => any) | undefined;
+}>, {
+    title: string;
+    description: string;
+    loading: boolean;
+    light: boolean;
+    showUptime: boolean;
+    showTemperature: boolean;
+    showLoadAverage: boolean;
+    showProcesses: boolean;
+    showMemory: boolean;
+    showCpu: boolean;
+    showStorage: boolean;
+    refreshable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/components/NS/cards/NSSystemdServiceCard.vue.d.ts

@@ -0,0 +1,47 @@
+interface ServiceStatus {
+    running: boolean;
+    enabled: boolean;
+    status?: string;
+    uptime?: string;
+    lastRestart?: string;
+    memory?: string;
+    cpu?: string;
+}
+interface Props {
+    title?: string;
+    description?: string;
+    icon?: any;
+    loading?: boolean;
+    status?: ServiceStatus;
+    serviceName?: string;
+    light?: boolean;
+    showUptime?: boolean;
+    showMetrics?: boolean;
+    maxHeight?: string;
+    class?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    stop: (serviceName: string) => any;
+    view: (serviceName: string) => any;
+    restart: (serviceName: string) => any;
+    start: (serviceName: string) => any;
+    enable: (serviceName: string) => any;
+    disable: (serviceName: string) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onStop?: ((serviceName: string) => any) | undefined;
+    onView?: ((serviceName: string) => any) | undefined;
+    onRestart?: ((serviceName: string) => any) | undefined;
+    onStart?: ((serviceName: string) => any) | undefined;
+    onEnable?: ((serviceName: string) => any) | undefined;
+    onDisable?: ((serviceName: string) => any) | undefined;
+}>, {
+    title: string;
+    status: ServiceStatus;
+    description: string;
+    loading: boolean;
+    light: boolean;
+    serviceName: string;
+    showUptime: boolean;
+    showMetrics: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/components/NS/cards/index.d.ts

@@ -0,0 +1,3 @@
+export { default as NSBackupCard } from './NSBackupCard.vue';
+export { default as NSSystemdServiceCard } from './NSSystemdServiceCard.vue';
+export { default as NSSystemInfoCard } from './NSSystemInfoCard.vue';

package/dist/src/components/NS/checkbox/NSCheckbox.vue.d.ts

@@ -0,0 +1,37 @@
+interface Props {
+    id?: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    value?: string;
+    label?: string;
+    hideLabel?: boolean;
+    description?: string;
+    errorMessage?: string;
+    indeterminate?: boolean;
+    class?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        label?(_: {}): any;
+        extra?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:checked": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:checked"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+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/src/components/NS/checkbox/index.d.ts

@@ -0,0 +1 @@
+export { default as NSCheckbox } from './NSCheckbox.vue';

package/dist/src/components/NS/data-table/NSDataTable.vue.d.ts

@@ -0,0 +1,98 @@
+interface Column {
+    key: string;
+    label: string;
+    sortable?: boolean;
+    width?: string;
+    align?: 'left' | 'center' | 'right';
+    filterable?: boolean;
+    render?: (value: any, row: any, index: number) => any;
+}
+interface Action {
+    key: string;
+    label: string;
+    icon?: any;
+    onClick: (row: any, index: number) => void;
+    disabled?: (row: any) => boolean;
+    variant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost' | 'link';
+}
+interface Props {
+    data?: any[];
+    columns?: Column[];
+    actions?: Action[];
+    loading?: boolean;
+    selectable?: boolean;
+    searchable?: boolean;
+    filterable?: boolean;
+    pagination?: boolean;
+    currentPage?: number;
+    itemsPerPage?: number;
+    totalItems?: number;
+    showTotal?: boolean;
+    emptyMessage?: string;
+    loadingMessage?: string;
+    maxHeight?: string;
+    striped?: boolean;
+    hover?: boolean;
+    class?: string;
+    tableClass?: string;
+    headerClass?: string;
+    bodyClass?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<`cell-${string}`, (_: {
+        row: any;
+        value: any;
+        column: Column;
+        index: number;
+    }) => any>> & {
+        pagination?(_: {
+            currentPage: number;
+            totalItems: number;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    search: (query: string) => any;
+    "update:currentPage": (page: number) => any;
+    "update:itemsPerPage": (size: number) => any;
+    "selection-change": (selectedRows: any[]) => any;
+    "row-click": (row: any, index: number) => any;
+    "sort-change": (column: string, direction: "desc" | "asc" | null) => any;
+    "filter-change": (filters: Record<string, any>) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onSearch?: ((query: string) => any) | undefined;
+    "onUpdate:currentPage"?: ((page: number) => any) | undefined;
+    "onUpdate:itemsPerPage"?: ((size: number) => any) | undefined;
+    "onSelection-change"?: ((selectedRows: any[]) => any) | undefined;
+    "onRow-click"?: ((row: any, index: number) => any) | undefined;
+    "onSort-change"?: ((column: string, direction: "desc" | "asc" | null) => any) | undefined;
+    "onFilter-change"?: ((filters: Record<string, any>) => any) | undefined;
+}>, {
+    data: any[];
+    loading: boolean;
+    actions: Action[];
+    currentPage: number;
+    totalItems: number;
+    itemsPerPage: number;
+    showTotal: boolean;
+    columns: Column[];
+    selectable: boolean;
+    searchable: boolean;
+    filterable: boolean;
+    pagination: boolean;
+    emptyMessage: string;
+    loadingMessage: string;
+    striped: boolean;
+    hover: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+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/src/components/NS/data-table/index.d.ts

@@ -0,0 +1 @@
+export { default as NSDataTable } from './NSDataTable.vue';

package/dist/src/components/NS/empty-state/NSEmptyState.vue.d.ts

@@ -0,0 +1,45 @@
+interface Props {
+    title?: string;
+    description?: string;
+    icon?: string | object;
+    lottiePath?: string;
+    lottieData?: any;
+    animationTitle?: string;
+    size?: 'default' | 'sm' | 'lg';
+    variant?: 'default' | 'muted';
+    loop?: boolean | number;
+    animateOnHover?: boolean;
+    autoPlay?: boolean;
+    class?: string;
+    iconClass?: string;
+    titleClass?: string;
+    descriptionClass?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        icon?(_: {}): any;
+        title?(_: {}): any;
+        description?(_: {}): any;
+        actions?(_: {}): any;
+        extra?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    title: string;
+    size: "default" | "sm" | "lg";
+    variant: "default" | "muted";
+    loop: boolean | number;
+    animateOnHover: boolean;
+    autoPlay: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+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/src/components/NS/empty-state/index.d.ts

@@ -0,0 +1 @@
+export { default as NSEmptyState } from './NSEmptyState.vue';

package/dist/src/components/NS/index.d.ts

@@ -0,0 +1,35 @@
+export { NSCheckbox } from './checkbox';
+export { NSTextInput } from './text-input';
+export { NSToggle } from './toggle';
+export { NSTag } from './tag';
+export { NSEmptyState } from './empty-state';
+export { NSInlineNotification } from './inline-notification';
+export { NSToastNotification } from './toast-notification';
+export { NSProgress, NSProgressBar } from './progress';
+export { NSModal, NSModalTrigger } from './modal';
+export { NSSlider, NSByteSlider } from './slider';
+export { NSPagination } from './pagination';
+export { NSDataTable } from './data-table';
+export { NSWizard } from './wizard';
+export { NSBackupCard, NSSystemdServiceCard, NSSystemInfoCard } from './cards';
+export { NSLottieAnimation } from './lottie-animation';
+export type { default as NSCheckboxType } from './checkbox/NSCheckbox.vue';
+export type { default as NSTextInputType } from './text-input/NSTextInput.vue';
+export type { default as NSToggleType } from './toggle/NSToggle.vue';
+export type { default as NSTagType } from './tag/NSTag.vue';
+export type { default as NSEmptyStateType } from './empty-state/NSEmptyState.vue';
+export type { default as NSInlineNotificationType } from './inline-notification/NSInlineNotification.vue';
+export type { default as NSToastNotificationType } from './toast-notification/NSToastNotification.vue';
+export type { default as NSProgressType } from './progress/NSProgress.vue';
+export type { default as NSProgressBarType } from './progress/NSProgressBar.vue';
+export type { default as NSModalType } from './modal/NSModal.vue';
+export type { default as NSModalTriggerType } from './modal/NSModalTrigger.vue';
+export type { default as NSSliderType } from './slider/NSSlider.vue';
+export type { default as NSByteSliderType } from './slider/NSByteSlider.vue';
+export type { default as NSPaginationType } from './pagination/NSPagination.vue';
+export type { default as NSDataTableType } from './data-table/NSDataTable.vue';
+export type { default as NSWizardType } from './wizard/NSWizard.vue';
+export type { default as NSBackupCardType } from './cards/NSBackupCard.vue';
+export type { default as NSSystemdServiceCardType } from './cards/NSSystemdServiceCard.vue';
+export type { default as NSSystemInfoCardType } from './cards/NSSystemInfoCard.vue';
+export type { default as NSLottieAnimationType } from './lottie-animation/NSLottieAnimation.vue';

package/dist/src/components/NS/inline-notification/NSInlineNotification.vue.d.ts

@@ -0,0 +1,44 @@
+interface Props {
+    title?: string;
+    description?: string;
+    variant?: 'default' | 'destructive' | 'warning' | 'success' | 'info';
+    showCloseButton?: boolean;
+    actionLabel?: string;
+    closeAriaLabel?: string;
+    loading?: boolean;
+    timer?: number;
+    lowContrast?: boolean;
+    class?: string;
+    icon?: object;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        title?(_: {}): any;
+        description?(_: {}): any;
+        extra?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: () => any;
+    action: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onAction?: (() => any) | undefined;
+}>, {
+    variant: "default" | "destructive" | "warning" | "success" | "info";
+    showCloseButton: boolean;
+    closeAriaLabel: string;
+    loading: boolean;
+    lowContrast: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+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/src/components/NS/inline-notification/index.d.ts

@@ -0,0 +1 @@
+export { default as NSInlineNotification } from './NSInlineNotification.vue';

package/dist/src/components/NS/lottie-animation/NSLottieAnimation.vue.d.ts

@@ -0,0 +1,75 @@
+interface Props {
+    path?: string;
+    animationData?: any;
+    width?: number | string;
+    height?: number | string;
+    loop?: boolean;
+    autoplay?: boolean;
+    speed?: number;
+    playOnHover?: boolean;
+    stopOnHoverOut?: boolean;
+    direction?: number;
+    renderer?: 'svg' | 'canvas' | 'html';
+    className?: string;
+    containerClassName?: string;
+    lazy?: boolean;
+    placeholder?: string;
+    responsive?: boolean;
+    preserveAspectRatio?: string;
+    title?: string;
+    ariaLabel?: string;
+    role?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {
+    play: () => void;
+    pause: () => void;
+    stop: () => void;
+    goToAndStop: (frame?: number) => void;
+    setDirection: (direction: number) => void;
+    setSpeed: (speed: number) => void;
+    isLoaded: import('vue').Ref<boolean, boolean>;
+    isPlaying: import('vue').Ref<boolean, boolean>;
+    isLoading: import('vue').Ref<boolean, boolean>;
+    isError: import('vue').Ref<boolean, boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    stop: () => any;
+    error: (error: Error) => any;
+    load: () => any;
+    ready: () => any;
+    play: () => any;
+    pause: () => any;
+    complete: () => any;
+    loopComplete: () => any;
+    enterFrame: (event: any) => any;
+    mouseOver: () => any;
+    mouseOut: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onStop?: (() => any) | undefined;
+    onError?: ((error: Error) => any) | undefined;
+    onLoad?: (() => any) | undefined;
+    onReady?: (() => any) | undefined;
+    onPlay?: (() => any) | undefined;
+    onPause?: (() => any) | undefined;
+    onComplete?: (() => any) | undefined;
+    onLoopComplete?: (() => any) | undefined;
+    onEnterFrame?: ((event: any) => any) | undefined;
+    onMouseOver?: (() => any) | undefined;
+    onMouseOut?: (() => any) | undefined;
+}>, {
+    preserveAspectRatio: string;
+    height: number | string;
+    width: number | string;
+    role: string;
+    direction: number;
+    speed: number;
+    loop: boolean;
+    autoplay: boolean;
+    playOnHover: boolean;
+    stopOnHoverOut: boolean;
+    renderer: "svg" | "canvas" | "html";
+    lazy: boolean;
+    responsive: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    lottieRef: any;
+}, HTMLDivElement>;
+export default _default;

package/dist/src/components/NS/lottie-animation/index.d.ts

@@ -0,0 +1 @@
+export { default as NSLottieAnimation } from './NSLottieAnimation.vue';

package/dist/src/components/NS/modal/NSModal.vue.d.ts

@@ -0,0 +1,56 @@
+interface Props {
+    open?: boolean;
+    modelValue?: boolean;
+    title?: string;
+    description?: string;
+    showCloseButton?: boolean;
+    closeOnOverlayClick?: boolean;
+    closeOnEscape?: boolean;
+    size?: 'sm' | 'default' | 'lg' | 'xl' | 'full';
+    maxWidth?: string;
+    maxHeight?: string;
+    persistent?: boolean;
+    fullscreen?: boolean;
+    class?: string;
+    contentClass?: string;
+    overlayClass?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        title?(_: {}): any;
+        description?(_: {}): any;
+        header?(_: {}): any;
+        default?(_: {}): any;
+        footer?(_: {}): any;
+        actions?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+    close: () => any;
+    open: () => any;
+    "update:open": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onOpen?: (() => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    size: "sm" | "default" | "lg" | "xl" | "full";
+    showCloseButton: boolean;
+    closeOnOverlayClick: boolean;
+    closeOnEscape: boolean;
+    persistent: boolean;
+    fullscreen: boolean;
+}, {}, {}, {}, 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/src/components/NS/modal/NSModalTrigger.vue.d.ts

@@ -0,0 +1,64 @@
+interface Props {
+    modelValue?: boolean;
+    open?: boolean;
+    title?: string;
+    description?: string;
+    showCloseButton?: boolean;
+    closeOnOverlayClick?: boolean;
+    closeOnEscape?: boolean;
+    size?: 'sm' | 'default' | 'lg' | 'xl' | 'full';
+    maxWidth?: string;
+    maxHeight?: string;
+    persistent?: boolean;
+    fullscreen?: boolean;
+    class?: string;
+    contentClass?: string;
+    overlayClass?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        trigger?(_: {
+            open: boolean;
+            toggle: () => boolean;
+        }): any;
+        default?(_: {}): any;
+        title?(_: {}): any;
+        description?(_: {}): any;
+        header?(_: {}): any;
+        actions?(_: {}): any;
+        footer?(_: {}): any;
+    };
+    refs: {
+        triggerRef: HTMLButtonElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+    close: () => any;
+    open: () => any;
+    "update:open": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onOpen?: (() => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    size: "sm" | "default" | "lg" | "xl" | "full";
+    showCloseButton: boolean;
+    closeOnOverlayClick: boolean;
+    closeOnEscape: boolean;
+    persistent: boolean;
+    fullscreen: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    triggerRef: HTMLButtonElement;
+}, 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/src/components/NS/modal/index.d.ts

@@ -0,0 +1,2 @@
+export { default as NSModal } from './NSModal.vue';
+export { default as NSModalTrigger } from './NSModalTrigger.vue';