@katlux/toolkit 0.1.0-beta.0 → 0.1.0-beta.11

package/dist/compiled/composables/useDebounce.mjs

@@ -0,0 +1,11 @@
+export const useDebounce = (callback, delay) => {
+  let timeoutId = null;
+  return function(...args) {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      callback.apply(this, args);
+    }, delay);
+  };
+};

package/dist/compiled/composables/useFilterLogic.mjs

@@ -0,0 +1,170 @@
+import { EDataFilterOperator } from "@katlux/providers";
+export const useFilterLogic = () => {
+  const evaluateFilter = (filter, row) => {
+    if (filter.operator === EDataFilterOperator.And || filter.operator === EDataFilterOperator.Or || filter.operator === EDataFilterOperator.Nand || filter.operator === EDataFilterOperator.Nor) {
+      return !filter.active || applyOperator(filter.operator, row, filter.field);
+    }
+    if ("operator" in filter.field && "field" in filter.field) {
+      return !filter.active || evaluateFilter(filter.field, row);
+    }
+    const field = filter.field;
+    const fieldKeys = Object.keys(field);
+    return !filter.active || fieldKeys.every((key) => {
+      const filterValue = field[key];
+      const rowValue = row[key];
+      return applyOperator(filter.operator, rowValue, filterValue);
+    });
+  };
+  const applyOperator = (operator, rowValue, filterValue) => {
+    switch (operator) {
+      case EDataFilterOperator.And:
+        return compareAnd(rowValue, filterValue);
+      case EDataFilterOperator.Or:
+        return compareOr(rowValue, filterValue);
+      case EDataFilterOperator.Nand:
+        return !compareAnd(rowValue, filterValue);
+      case EDataFilterOperator.Nor:
+        return !compareOr(rowValue, filterValue);
+      case EDataFilterOperator.Equal:
+        return compareEqual(rowValue, filterValue);
+      case EDataFilterOperator.NotEqual:
+        return !compareEqual(rowValue, filterValue);
+      case EDataFilterOperator.GreaterThan:
+        return compareValues(rowValue, filterValue) > 0;
+      case EDataFilterOperator.LessThan:
+        return compareValues(rowValue, filterValue) < 0;
+      case EDataFilterOperator.GreaterThanOrEqual:
+        return compareValues(rowValue, filterValue) >= 0;
+      case EDataFilterOperator.LessThanOrEqual:
+        return compareValues(rowValue, filterValue) <= 0;
+      case EDataFilterOperator.In:
+        return compareIn(rowValue, filterValue);
+      case EDataFilterOperator.NotIn:
+        return !compareIn(rowValue, filterValue);
+      default:
+        return compareEqual(rowValue, filterValue);
+    }
+  };
+  const compareAnd = (row, nested) => {
+    const subFilters = Array.isArray(nested) ? nested : nested && typeof nested === "object" ? Object.values(nested) : [];
+    const validFilters = subFilters.filter((f) => f && typeof f === "object" && "operator" in f && "field" in f);
+    if (validFilters.length === 0) return true;
+    return validFilters.every((f) => {
+      const active = f.active !== false;
+      return active ? evaluateFilter(f, row) : true;
+    });
+  };
+  const compareOr = (row, nested) => {
+    const subFilters = Array.isArray(nested) ? nested : nested && typeof nested === "object" ? Object.values(nested) : [];
+    const validFilters = subFilters.filter((f) => f && typeof f === "object" && "operator" in f && "field" in f);
+    const activeFilters = validFilters.filter((f) => f.active !== false);
+    if (activeFilters.length === 0) return true;
+    return activeFilters.some((f) => {
+      return evaluateFilter(f, row);
+    });
+  };
+  const compareIn = (rowValue, filterValue) => {
+    if (typeof rowValue === "string" && typeof filterValue === "string") {
+      return rowValue.toLowerCase().includes(filterValue.toLowerCase());
+    }
+    return false;
+  };
+  const compareEqual = (rowValue, filterValue) => {
+    if (typeof rowValue === "string" && typeof filterValue === "string") {
+      return rowValue.toLowerCase() == filterValue.toLowerCase();
+    }
+    if (typeof rowValue === "number" && typeof filterValue === "number") {
+      return rowValue === filterValue;
+    }
+    if (typeof rowValue === "boolean" && typeof filterValue === "boolean") {
+      return rowValue === filterValue;
+    }
+    return rowValue === filterValue;
+  };
+  const compareValues = (rowValue, filterValue) => {
+    if (rowValue == null || filterValue == null) {
+      return rowValue == null ? -1 : 1;
+    }
+    if (typeof rowValue === "string" && typeof filterValue === "string") {
+      return rowValue.localeCompare(filterValue);
+    }
+    if (typeof rowValue === "number" && typeof filterValue === "number") {
+      return rowValue - filterValue;
+    }
+    return String(rowValue).localeCompare(String(filterValue));
+  };
+  const filterTreeData = (nodes, filter, options) => {
+    const { idKey, parentKey } = options;
+    const nodeMap = new Map(nodes.map((node) => [node[idKey], node]));
+    const childrenMap = /* @__PURE__ */ new Map();
+    nodes.forEach((node) => {
+      const pId = node[parentKey];
+      if (pId != null) {
+        if (!childrenMap.has(pId)) {
+          childrenMap.set(pId, []);
+        }
+        childrenMap.get(pId).push(node);
+      }
+    });
+    const matchingNodeIds = /* @__PURE__ */ new Set();
+    const expandedNodes = /* @__PURE__ */ new Set();
+    const visibleNodeIds = /* @__PURE__ */ new Set();
+    nodes.forEach((node) => {
+      const evalRow = node.data ? { ...node.data, ...node } : node;
+      if (evaluateFilter(filter, evalRow)) {
+        matchingNodeIds.add(node[idKey]);
+      }
+    });
+    const addDescendants = (nodeId) => {
+      const children = childrenMap.get(nodeId);
+      if (children && children.length > 0) {
+        expandedNodes.add(nodeId);
+        children.forEach((child) => {
+          visibleNodeIds.add(child[idKey]);
+          addDescendants(child[idKey]);
+        });
+      }
+    };
+    matchingNodeIds.forEach((id) => {
+      visibleNodeIds.add(id);
+      addDescendants(id);
+      let currentId = id;
+      while (currentId != null) {
+        visibleNodeIds.add(currentId);
+        const node = nodeMap.get(currentId);
+        if (node) {
+          if (node[parentKey] != null) {
+            expandedNodes.add(node[parentKey]);
+            currentId = node[parentKey];
+          } else {
+            currentId = null;
+          }
+        } else {
+          break;
+        }
+      }
+    });
+    const visibleNodes = nodes.filter((node) => visibleNodeIds.has(node[idKey]));
+    return {
+      visibleNodes,
+      expandedNodes
+    };
+  };
+  const filterData = (data, filter, options) => {
+    if (options?.treeOptions) {
+      const { visibleNodes, expandedNodes } = filterTreeData(
+        data,
+        filter,
+        options.treeOptions
+      );
+      return { results: visibleNodes, expandedNodes };
+    }
+    const results = data.filter((row) => evaluateFilter(filter, row));
+    return { results };
+  };
+  return {
+    evaluateFilter,
+    filterTreeData,
+    filterData
+  };
+};

package/dist/compiled/composables/usePresetComponent.mjs

@@ -0,0 +1,36 @@
+import { computed, defineAsyncComponent } from "vue";
+import { useAppConfig } from "#app";
+const componentCache = /* @__PURE__ */ new Map();
+const modernComponents = import.meta.glob("../../../../katlux-preset-modern/src/runtime/components/**/*.vue");
+const toolkitPresets = import.meta.glob("../presets/**/*.vue");
+export function usePresetComponent(componentBaseName, defaultComponent) {
+  const appConfig = useAppConfig();
+  const activePreset = computed(() => appConfig.katluxToolkit?.activePreset || "default");
+  return computed(() => {
+    if (activePreset.value === "default") {
+      return defaultComponent;
+    }
+    const cacheKey = `${activePreset.value}:${componentBaseName}`;
+    if (componentCache.has(cacheKey)) {
+      return componentCache.get(cacheKey);
+    }
+    let loader;
+    if (activePreset.value === "modern") {
+      const path = `../../../../katlux-preset-modern/src/runtime/components/${componentBaseName}/${componentBaseName}.vue`;
+      loader = modernComponents[path];
+    } else {
+      const path = `../presets/${activePreset.value}/components/${componentBaseName}/${componentBaseName}.vue`;
+      loader = toolkitPresets[path];
+    }
+    if (!loader) {
+      console.warn(`[${componentBaseName}] Preset "${activePreset.value}" not found, falling back to default`);
+      return defaultComponent;
+    }
+    const asyncComp = defineAsyncComponent({
+      loader,
+      errorComponent: defaultComponent
+    });
+    componentCache.set(cacheKey, asyncComp);
+    return asyncComp;
+  });
+}

package/dist/compiled/composables/useRemainingTime.mjs

@@ -0,0 +1,17 @@
+export const useRemainingTime = () => {
+  const formatRemainingTime = (ms) => {
+    if (ms <= 0) return "expired";
+    const seconds = Math.floor(ms / 1e3);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0) return `${days}d`;
+    if (hours > 0) return `${hours}h`;
+    if (minutes > 0) return `${minutes}m`;
+    if (seconds > 0) return `${seconds}s`;
+    return "0s";
+  };
+  return {
+    formatRemainingTime
+  };
+};

package/dist/compiled/composables/useSortLogic.mjs

@@ -0,0 +1,55 @@
+export const useSortLogic = () => {
+  const sortData = (sortList, rows) => {
+    if (!sortList || sortList.length === 0 || !rows || rows.length === 0) {
+      return rows;
+    }
+    const sortedRows = [...rows];
+    const compare = (a, b) => {
+      for (const sort of sortList) {
+        const aVal = a[sort.field];
+        const bVal = b[sort.field];
+        if (aVal === null || aVal === void 0) {
+          if (bVal === null || bVal === void 0) continue;
+          return sort.direction === "asc" ? -1 : 1;
+        }
+        if (bVal === null || bVal === void 0) {
+          return sort.direction === "asc" ? 1 : -1;
+        }
+        if (aVal < bVal) {
+          return sort.direction === "asc" ? -1 : 1;
+        } else if (aVal > bVal) {
+          return sort.direction === "asc" ? 1 : -1;
+        }
+      }
+      return 0;
+    };
+    const merge = (left, right) => {
+      const result = [];
+      let leftIndex = 0;
+      let rightIndex = 0;
+      while (leftIndex < left.length && rightIndex < right.length) {
+        if (compare(left[leftIndex], right[rightIndex]) <= 0) {
+          result.push(left[leftIndex]);
+          leftIndex++;
+        } else {
+          result.push(right[rightIndex]);
+          rightIndex++;
+        }
+      }
+      return result.concat(left.slice(leftIndex)).concat(right.slice(rightIndex));
+    };
+    const mergeSort = (arr) => {
+      if (arr.length <= 1) {
+        return arr;
+      }
+      const mid = Math.floor(arr.length / 2);
+      const left = mergeSort(arr.slice(0, mid));
+      const right = mergeSort(arr.slice(mid));
+      return merge(left, right);
+    };
+    return mergeSort(sortedRows);
+  };
+  return {
+    sortData
+  };
+};

package/dist/compiled/composables/useTemplate.mjs

@@ -0,0 +1,70 @@
+import { ref, computed, onMounted } from "vue";
+import { useTemplateResolver } from "../utils/TemplateResolver";
+export function useTemplate(options) {
+  const { componentName, fallbackToDefault = true } = options;
+  const resolver = useTemplateResolver();
+  const metadata = ref(resolver.resolveTemplate(componentName));
+  const isLoading = ref(false);
+  const error = ref(null);
+  const isCustomTemplate = computed(() => {
+    return metadata.value.hasCustomTemplate && metadata.value.templateName !== "default";
+  });
+  const templateName = computed(() => {
+    return metadata.value.templateName;
+  });
+  const refreshTemplate = () => {
+    try {
+      isLoading.value = true;
+      error.value = null;
+      resolver.clearCache();
+      metadata.value = resolver.resolveTemplate(componentName);
+    } catch (e) {
+      error.value = e;
+      console.error(`Failed to refresh template for ${componentName}:`, e);
+      if (fallbackToDefault) {
+        console.warn(`Falling back to default template for ${componentName}`);
+        resolver.setActiveTemplate("default");
+        metadata.value = resolver.resolveTemplate(componentName);
+      }
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  onMounted(() => {
+    refreshTemplate();
+  });
+  return {
+    metadata,
+    isCustomTemplate,
+    templateName,
+    isLoading,
+    error,
+    refreshTemplate
+  };
+}
+export function useTemplateStyles(componentName) {
+  const resolver = useTemplateResolver();
+  const metadata = resolver.resolveTemplate(componentName);
+  const isLoaded = ref(false);
+  const error = ref(null);
+  const loadStyles = async () => {
+    if (!metadata.hasCustomStyles || !metadata.stylesPath) {
+      isLoaded.value = true;
+      return;
+    }
+    try {
+      isLoaded.value = true;
+    } catch (e) {
+      error.value = e;
+      console.error(`Failed to load styles for ${componentName}:`, e);
+    }
+  };
+  onMounted(() => {
+    loadStyles();
+  });
+  return {
+    isLoaded,
+    error,
+    loadStyles
+  };
+}

package/dist/compiled/utils/PresetResolver.mjs

@@ -0,0 +1,100 @@
+import { useRuntimeConfig, useAppConfig, useCookie, useNuxtApp } from "#app";
+export class PresetResolver {
+  cache = {};
+  activePreset = "default";
+  presetsDir = "~/presets";
+  constructor() {
+    this.initialize();
+  }
+  /**
+   * Initialize the preset resolver with configuration
+   */
+  initialize() {
+    try {
+      const appConfig = useAppConfig();
+      const runtimeConfig = useRuntimeConfig();
+      const presetCookie = useCookie("katlux-active-preset");
+      if (presetCookie.value) {
+        this.activePreset = presetCookie.value;
+      } else if (appConfig.katluxToolkit?.activePreset) {
+        this.activePreset = appConfig.katluxToolkit.activePreset;
+      }
+      const publicConfig = runtimeConfig.public;
+      if (publicConfig?.katluxToolkit?.presetsDir) {
+        this.presetsDir = publicConfig.katluxToolkit.presetsDir;
+      }
+    } catch (error) {
+      console.warn("PresetResolver: Could not load configuration, using defaults", error);
+    }
+  }
+  /**
+   * Resolve preset metadata for a given component
+   * @param componentName - Name of the component (e.g., 'KButton')
+   * @returns Preset metadata including paths and availability
+   */
+  resolvePreset(componentName) {
+    const cacheKey = `${this.activePreset}:${componentName}`;
+    if (this.cache[cacheKey]) {
+      return this.cache[cacheKey];
+    }
+    const metadata = {
+      componentName,
+      presetName: this.activePreset,
+      hasCustomPreset: false,
+      hasCustomStyles: false
+    };
+    if (this.activePreset !== "default") {
+      const customPresetPath = `${this.presetsDir}/${this.activePreset}/${componentName}.pug`;
+      const customStylesPath = `${this.presetsDir}/${this.activePreset}/${componentName}.scss`;
+      metadata.presetPath = customPresetPath;
+      metadata.stylesPath = customStylesPath;
+      metadata.hasCustomPreset = true;
+      metadata.hasCustomStyles = true;
+    }
+    this.cache[cacheKey] = metadata;
+    return metadata;
+  }
+  /**
+   * Get the active preset name
+   */
+  getActivePreset() {
+    return this.activePreset;
+  }
+  /**
+   * Set the active preset (useful for runtime switching)
+   * @param presetName - Name of the preset to activate
+   */
+  setActivePreset(presetName) {
+    if (this.activePreset !== presetName) {
+      this.activePreset = presetName;
+      this.clearCache();
+      const presetCookie = useCookie("katlux-active-preset");
+      presetCookie.value = presetName;
+    }
+  }
+  /**
+   * Clear the preset cache (useful when presets change in dev mode)
+   */
+  clearCache() {
+    this.cache = {};
+  }
+  /**
+   * Get all cached preset metadata
+   */
+  getCachedPresets() {
+    return { ...this.cache };
+  }
+  /**
+   * Check if a custom preset exists for a component
+   * @param componentName - Name of the component
+   * @returns True if custom preset exists
+   */
+  hasCustomPreset(componentName) {
+    const metadata = this.resolvePreset(componentName);
+    return metadata.hasCustomPreset;
+  }
+}
+export function usePresetResolver() {
+  const nuxtApp = useNuxtApp();
+  return nuxtApp.$presetResolver;
+}

package/dist/module.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+const kit = require('@nuxt/kit');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const module$1 = kit.defineNuxtModule({
+  meta: {
+    name: "@katlux/toolkit",
+    configKey: "katluxToolkit"
+  },
+  setup(options, nuxt) {
+    const { resolve } = kit.createResolver((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('module.cjs', document.baseURI).href)));
+    nuxt.options.build.transpile.push(resolve("./runtime"));
+    nuxt.options.css.push(resolve("./runtime/presets/default/assets/scss/index.scss"));
+    kit.addComponentsDir({
+      path: resolve("./runtime/components"),
+      pathPrefix: false,
+      extensions: ["vue"],
+      global: true
+    });
+    kit.addImportsDir(resolve("./runtime/composables"));
+    kit.addPlugin(resolve("./runtime/plugins/registerDirectives"));
+    kit.addPlugin(resolve("./runtime/plugins/PresetPlugin"));
+    nuxt.options.alias["#toolkit"] = resolve("./runtime");
+    nuxt.hook("prepare:types", (options2) => {
+      options2.tsConfig.compilerOptions = options2.tsConfig.compilerOptions || {};
+      options2.tsConfig.compilerOptions.allowArbitraryExtensions = true;
+    });
+  }
+});
+
+module.exports = module$1;

package/dist/module.d.cts

@@ -0,0 +1,5 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+declare const _default: _nuxt_schema.NuxtModule<_nuxt_schema.ModuleOptions, _nuxt_schema.ModuleOptions, false>;
+
+export = _default;

package/dist/module.d.mts

@@ -0,0 +1,5 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+declare const _default: _nuxt_schema.NuxtModule<_nuxt_schema.ModuleOptions, _nuxt_schema.ModuleOptions, false>;
+
+export { _default as default };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "@katlux/toolkit",
+  "configKey": "katluxToolkit",
+  "version": "0.1.0-beta.11",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,29 @@
+import { defineNuxtModule, createResolver, addComponentsDir, addImportsDir, addPlugin } from '@nuxt/kit';
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "@katlux/toolkit",
+    configKey: "katluxToolkit"
+  },
+  setup(options, nuxt) {
+    const { resolve } = createResolver(import.meta.url);
+    nuxt.options.build.transpile.push(resolve("./runtime"));
+    nuxt.options.css.push(resolve("./runtime/presets/default/assets/scss/index.scss"));
+    addComponentsDir({
+      path: resolve("./runtime/components"),
+      pathPrefix: false,
+      extensions: ["vue"],
+      global: true
+    });
+    addImportsDir(resolve("./runtime/composables"));
+    addPlugin(resolve("./runtime/plugins/registerDirectives"));
+    addPlugin(resolve("./runtime/plugins/PresetPlugin"));
+    nuxt.options.alias["#toolkit"] = resolve("./runtime");
+    nuxt.hook("prepare:types", (options2) => {
+      options2.tsConfig.compilerOptions = options2.tsConfig.compilerOptions || {};
+      options2.tsConfig.compilerOptions.allowArbitraryExtensions = true;
+    });
+  }
+});
+
+export { module$1 as default };

package/dist/runtime/components/KAccordion/KAccordion.global.d.vue.ts

@@ -0,0 +1,13 @@
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    multiOpen: {
+        type: BooleanConstructor;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    multiOpen: {
+        type: BooleanConstructor;
+    };
+}>> & Readonly<{}>, {
+    multiOpen: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/KAccordion/KAccordion.global.vue

@@ -0,0 +1,15 @@
+<script setup>
+import { useKAccordionLogic, KAccordionDefaultProps } from "./KAccordion.logic";
+import { usePresetComponent } from "../../composables/usePresetComponent";
+import { computed } from "vue";
+import KAccordionDefault from "../../presets/default/components/KAccordion/KAccordion.vue";
+const props = defineProps(KAccordionDefaultProps);
+useKAccordionLogic(props);
+const presetComponent = usePresetComponent("KAccordion", KAccordionDefault);
+</script>
+
+<template lang="pug">
+component(:is="presetComponent")
+	template(v-for="(_, slot) in $slots" #[slot]="scope")
+		slot(:name="slot" v-bind="scope")
+</template>

package/dist/runtime/components/KAccordion/KAccordion.global.vue.d.ts

@@ -0,0 +1,13 @@
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    multiOpen: {
+        type: BooleanConstructor;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    multiOpen: {
+        type: BooleanConstructor;
+    };
+}>> & Readonly<{}>, {
+    multiOpen: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/KAccordion/KAccordion.logic.d.ts

@@ -0,0 +1,9 @@
+export interface KAccordionProps {
+    multiOpen?: boolean;
+}
+export declare const KAccordionDefaultProps: {
+    multiOpen: {
+        type: BooleanConstructor;
+    };
+};
+export declare function useKAccordionLogic(props: KAccordionProps): {};

package/dist/runtime/components/KAccordion/KAccordion.logic.js

@@ -0,0 +1,38 @@
+import { ref, provide } from "vue";
+export const KAccordionDefaultProps = {
+  multiOpen: {
+    type: Boolean
+  }
+};
+export function useKAccordionLogic(props) {
+  const openIds = ref([]);
+  const items = ref(/* @__PURE__ */ new Map());
+  function registerItem(id, item) {
+    items.value.set(id, item);
+    return () => {
+      items.value.delete(id);
+    };
+  }
+  function toggleItem(id) {
+    if (props.multiOpen) {
+      if (openIds.value.includes(id)) {
+        openIds.value = openIds.value.filter((i) => i !== id);
+      } else {
+        openIds.value.push(id);
+      }
+    } else {
+      if (openIds.value[0] === id) {
+        openIds.value = [];
+      } else {
+        openIds.value = [id];
+      }
+    }
+  }
+  function isOpen(id) {
+    return openIds.value.includes(id);
+  }
+  provide("accordionRegister", registerItem);
+  provide("accordionToggle", toggleItem);
+  provide("accordionIsOpen", isOpen);
+  return {};
+}

package/dist/runtime/components/KAccordion/KAccordionItem.global.d.vue.ts

@@ -0,0 +1,21 @@
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    isOpen: {
+        type: BooleanConstructor;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    isOpen: {
+        type: BooleanConstructor;
+    };
+}>> & Readonly<{}>, {
+    isOpen: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;