nuxt-ui-tools 0.1.0

package/dist/runtime/spreadsheet/utils/source/core.js

@@ -0,0 +1,54 @@
+import { read, utils } from "xlsx";
+async function resolveSpreadsheetBinarySource(source) {
+  if (source instanceof Uint8Array) return source;
+  if (source instanceof ArrayBuffer) return new Uint8Array(source);
+  return new Uint8Array(await source.arrayBuffer());
+}
+function normalizeSheetRows(rows) {
+  return rows.map((row) => row.map((cell) => cell ?? ""));
+}
+export async function parseSpreadsheetWorkbook(params) {
+  const data = await resolveSpreadsheetBinarySource(params.source);
+  const workbook = read(data, {
+    type: "array",
+    cellDates: true
+  });
+  const sheets = workbook.SheetNames.map((sheetName) => {
+    const sheet = workbook.Sheets[sheetName];
+    if (!sheet)
+      return {
+        name: sheetName,
+        rows: []
+      };
+    return {
+      name: sheetName,
+      rows: normalizeSheetRows(
+        utils.sheet_to_json(sheet, {
+          header: 1,
+          raw: false,
+          defval: "",
+          blankrows: false
+        })
+      )
+    };
+  });
+  return {
+    fileName: params.fileName,
+    sheets
+  };
+}
+export function getDefaultSpreadsheetSheetName(workbook) {
+  return workbook?.sheets[0]?.name;
+}
+export function getSpreadsheetSheet(workbook, sheetName) {
+  if (!workbook) return null;
+  if (!sheetName) return workbook.sheets[0] ?? null;
+  return workbook.sheets.find((sheet) => sheet.name === sheetName) ?? workbook.sheets[0] ?? null;
+}
+export function getSpreadsheetHeaders(sheet, headerRowIndex) {
+  return sheet?.rows[headerRowIndex] ?? [];
+}
+export function getSpreadsheetDataRows(sheet, headerRowIndex) {
+  if (!sheet) return [];
+  return sheet.rows.slice(headerRowIndex + 1);
+}

package/dist/runtime/spreadsheet/utils/source/index.d.ts

@@ -0,0 +1 @@
+export * from './core.js';

package/dist/runtime/spreadsheet/utils/source/index.js

@@ -0,0 +1 @@
+export * from "./core.js";

package/dist/runtime/spreadsheet/utils/validation/core.d.ts

@@ -0,0 +1,16 @@
+import type { CreateSpreadsheetRule, SpreadsheetFieldRules, SpreadsheetFieldRulesInput, SpreadsheetRuleBuilder } from '../../types/validation.js';
+export declare const createSheetRule: CreateSpreadsheetRule;
+export declare function resolveSpreadsheetRules<TValue>(rules: SpreadsheetFieldRulesInput<TValue> | undefined): SpreadsheetFieldRules<TValue>;
+export declare function resolveSpreadsheetRelationRules<TRow, TValue>(params: {
+    row: TRow;
+    rules: (rules: SpreadsheetRuleBuilder, row: TRow) => SpreadsheetFieldRules<TValue>;
+}): SpreadsheetFieldRules<TValue>;
+export declare function executeSpreadsheetRules<TValue>(params: {
+    value: TValue;
+    rules: SpreadsheetFieldRulesInput<TValue> | undefined;
+}): {
+    ruleKey: string | undefined;
+    level: import("../../types/index.js").SpreadsheetIssueLevel;
+    code: string;
+    message: string;
+}[];

package/dist/runtime/spreadsheet/utils/validation/core.js

@@ -0,0 +1,192 @@
+import { useUiToolsLocale } from "#ui-tools/i18n";
+function isSpreadsheetRecord(value) {
+  return value !== null && typeof value === "object";
+}
+function isSpreadsheetRuleOverride(value) {
+  return isSpreadsheetRecord(value) && "message" in value;
+}
+function resolveSpreadsheetRuleFactoryInput(input) {
+  const lastItem = input.at(-1);
+  if (!isSpreadsheetRuleOverride(lastItem))
+    return {
+      params: input,
+      overrides: void 0
+    };
+  return {
+    params: input.slice(0, -1),
+    overrides: lastItem
+  };
+}
+function createSpreadsheetRuleInstance(options) {
+  return {
+    $rule: true,
+    flags: options.flags,
+    name: options.name,
+    level: "error",
+    validate(value) {
+      const messageResolver = options.message;
+      const rawResult = options.validator(value, ...options.params);
+      if (typeof rawResult === "boolean") {
+        if (rawResult)
+          return {
+            $valid: true,
+            $message: null,
+            $meta: Object.fromEntries([])
+          };
+        return {
+          $valid: false,
+          $message: typeof messageResolver === "function" ? String(
+            messageResolver({
+              $valid: false,
+              value,
+              params: options.params
+            })
+          ) : messageResolver,
+          $meta: Object.fromEntries([])
+        };
+      }
+      const metaEntries = Object.entries(rawResult).filter(([key]) => key !== "$valid");
+      const result = {
+        $valid: rawResult.$valid,
+        $message: null,
+        $meta: Object.fromEntries(metaEntries)
+      };
+      if (result.$valid)
+        return {
+          $valid: true,
+          $message: null,
+          $meta: result.$meta
+        };
+      return {
+        ...result,
+        $message: typeof messageResolver === "function" ? String(
+          messageResolver({
+            value,
+            params: options.params,
+            ...rawResult
+          })
+        ) : messageResolver
+      };
+    }
+  };
+}
+function createRule(options) {
+  return (...input) => {
+    const { params, overrides } = resolveSpreadsheetRuleFactoryInput(input);
+    return createSpreadsheetRuleInstance({
+      flags: options.flags,
+      name: options.name,
+      validator: options.validator,
+      params,
+      message: overrides?.message ?? options.message
+    });
+  };
+}
+function validate(options) {
+  const createInlineRule = createRule({
+    name: options.name,
+    validator: options.validator,
+    message: options.message
+  });
+  return createInlineRule();
+}
+function createNumericValueGuard(value) {
+  return !Number.isNaN(value) && Number.isFinite(value);
+}
+const createSpreadsheetRuleBuilder = () => {
+  const { t } = useUiToolsLocale();
+  return {
+    validate,
+    required: createRule({
+      name: "required",
+      flags: { required: true },
+      validator: (value) => value != null && value !== "",
+      message: () => t("spreadsheet.validation.required")
+    }),
+    maxLength: createRule({
+      name: "maxLength",
+      validator: (value, max) => ({
+        $valid: value.length <= max,
+        max
+      }),
+      message: ({ value, params: [max] }) => t("spreadsheet.validation.maxLength", { max, length: value.length })
+    }),
+    minLength: createRule({
+      name: "minLength",
+      validator: (value, min) => ({
+        $valid: value.length >= min,
+        min
+      }),
+      message: ({ value, params: [min] }) => t("spreadsheet.validation.minLength", { min, length: value.length })
+    }),
+    number: createRule({
+      name: "number",
+      validator: (value) => createNumericValueGuard(value),
+      message: () => t("spreadsheet.validation.number")
+    }),
+    min: createRule({
+      name: "min",
+      validator: (value, min) => ({
+        $valid: createNumericValueGuard(value) && value >= min,
+        min
+      }),
+      message: ({ value, params: [min] }) => t("spreadsheet.validation.min", { value, min })
+    }),
+    max: createRule({
+      name: "max",
+      validator: (value, max) => ({
+        $valid: createNumericValueGuard(value) && value <= max,
+        max
+      }),
+      message: ({ value, params: [max] }) => t("spreadsheet.validation.max", { value, max })
+    }),
+    between: createRule({
+      name: "between",
+      validator: (value, min, max) => ({
+        $valid: createNumericValueGuard(value) && value >= min && value <= max,
+        min,
+        max
+      }),
+      message: ({ value, params: [min, max] }) => t("spreadsheet.validation.between", { value, min, max })
+    }),
+    oneOf(values, overrides) {
+      const ruleFactory = createRule({
+        name: "oneOf",
+        validator: (value, allowedValues) => ({
+          $valid: allowedValues.includes(value),
+          values: allowedValues
+        }),
+        message: ({ value, params: [allowedValues] }) => t("spreadsheet.validation.oneOf", {
+          value: String(value),
+          values: allowedValues.map(String).join(", ")
+        })
+      });
+      return ruleFactory(values, overrides);
+    }
+  };
+};
+export const createSheetRule = createRule;
+export function resolveSpreadsheetRules(rules) {
+  if (!rules) return [];
+  if (typeof rules === "function") return rules(createSpreadsheetRuleBuilder());
+  return rules;
+}
+export function resolveSpreadsheetRelationRules(params) {
+  return params.rules(createSpreadsheetRuleBuilder(), params.row);
+}
+export function executeSpreadsheetRules(params) {
+  const rules = resolveSpreadsheetRules(params.rules);
+  if (!rules.length) return [];
+  return rules.flatMap((rule, index) => {
+    const result = rule.validate(params.value);
+    if (result.$valid) return [];
+    return [
+      {
+        ruleKey: rule.name,
+        level: rule.level,
+        code: rule.name ?? `rule.${index}`,
+        message: result.$message ?? ""
+      }
+    ];
+  });
+}

package/dist/runtime/spreadsheet/utils/validation/index.d.ts

@@ -0,0 +1 @@
+export * from './core.js';

package/dist/runtime/spreadsheet/utils/validation/index.js

@@ -0,0 +1 @@
+export * from "./core.js";

package/dist/runtime/table/builders/index.d.ts

@@ -0,0 +1,7 @@
+import type { GenericObject, TableColumnBuilder, TableColumnCollection, TableFilterBuilder, TableSortKey, TableUiFilterCollection, TableUiFilterDefinition } from '../types/index.js';
+export declare function createTableColumnBuilder<TRow extends GenericObject, TContext extends GenericObject, TPageContext extends GenericObject, TSortKey extends string = TableSortKey<TRow>>(): TableColumnBuilder<TRow, TContext, TPageContext, TSortKey>;
+export declare function createTableFilterBuilder<TRow extends GenericObject, TContext extends GenericObject = GenericObject>(): TableFilterBuilder<TRow, TContext>;
+export declare function resolveCollection<TBuilder, TResult>(collection: TResult | ((builder: TBuilder) => TResult) | undefined, builder: TBuilder): TResult | undefined;
+export declare function resolveColumns<TRow extends GenericObject, TContext extends GenericObject, TPageContext extends GenericObject, TSortKey extends string = TableSortKey<TRow>, TColumns extends TableColumnCollection<TRow, TContext, TPageContext, string, TSortKey> | undefined = TableColumnCollection<TRow, TContext, TPageContext, string, TSortKey> | undefined>(columns: TColumns): TColumns extends (...args: never[]) => infer TResult ? TResult : TColumns;
+export declare function resolveUiFilters<TRow extends GenericObject, TContext extends GenericObject, TKey extends string>(filters: TableUiFilterCollection<TRow, TContext, TKey> | undefined): TableUiFilterDefinition<TRow, TContext, TKey>[] | undefined;
+export type { TableSortKey };

package/dist/runtime/table/builders/index.js

@@ -0,0 +1,83 @@
+export function createTableColumnBuilder() {
+  return {
+    field(field, options = {}) {
+      return {
+        kind: "field",
+        key: field,
+        field,
+        ...options
+      };
+    },
+    composite(key, options) {
+      return {
+        kind: "composite",
+        key,
+        ...options
+      };
+    },
+    display(key, options) {
+      return {
+        kind: "display",
+        key,
+        ...options
+      };
+    }
+  };
+}
+export function createTableFilterBuilder() {
+  return {
+    text(key, options) {
+      return {
+        kind: "text",
+        key,
+        ...options
+      };
+    },
+    option(key, options) {
+      return {
+        kind: "option",
+        key,
+        ...options
+      };
+    },
+    boolean(key, options) {
+      return {
+        kind: "boolean",
+        key,
+        ...options
+      };
+    },
+    number(key, options) {
+      return {
+        kind: "number",
+        key,
+        ...options
+      };
+    },
+    date(key, options) {
+      return {
+        kind: "date",
+        key,
+        ...options
+      };
+    }
+  };
+}
+export function resolveCollection(collection, builder) {
+  if (!collection) {
+    return void 0;
+  }
+  if (typeof collection === "function") {
+    return collection(builder);
+  }
+  return collection;
+}
+export function resolveColumns(columns) {
+  return resolveCollection(
+    columns,
+    createTableColumnBuilder()
+  );
+}
+export function resolveUiFilters(filters) {
+  return resolveCollection(filters, createTableFilterBuilder());
+}

package/dist/runtime/table/components/DataList.d.vue.ts

@@ -0,0 +1,72 @@
+import type { ComputedRef } from 'vue';
+import type { UiToolsLocale, UiToolsMessages } from '#ui-tools/i18n';
+import type { TableInternals } from '../composables/use-table-internals.js';
+import type { DataListDensity, DataListUiConfig } from '../types/index.js';
+type DataListTable = {
+    schema: ComputedRef<{
+        tableKey: string;
+    }>;
+    __internals: TableInternals;
+};
+type __VLS_Props = {
+    table: DataListTable;
+    title?: string;
+    description?: string;
+    height?: string | number;
+    locale?: UiToolsLocale<UiToolsMessages>;
+    density?: DataListDensity;
+    ui?: DataListUiConfig;
+};
+declare var __VLS_15: {}, __VLS_18: {}, __VLS_21: {
+    layout: string;
+    refresh: () => void;
+}, __VLS_24: {}, __VLS_27: {}, __VLS_30: {
+    layout: "table" | "grid";
+}, __VLS_33: {
+    layout: "table" | "grid";
+}, __VLS_36: {
+    error: {};
+    retry: () => void;
+}, __VLS_39: {
+    loadedCount: number;
+}, __VLS_42: {
+    error: {};
+    retry: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverRefetchErrorResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverSuccessResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverLoadingErrorResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverPendingResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverPlaceholderResult<unknown, unknown> | undefined>;
+}, __VLS_45: {
+    loadedCount: number;
+    totalCount: number | null;
+}, __VLS_48: {};
+type __VLS_Slots = {} & {
+    title?: (props: typeof __VLS_15) => any;
+} & {
+    actions?: (props: typeof __VLS_18) => any;
+} & {
+    empty?: (props: typeof __VLS_21) => any;
+} & {
+    'empty-table'?: (props: typeof __VLS_24) => any;
+} & {
+    'empty-grid'?: (props: typeof __VLS_27) => any;
+} & {
+    loading?: (props: typeof __VLS_30) => any;
+} & {
+    'initial-loading'?: (props: typeof __VLS_33) => any;
+} & {
+    error?: (props: typeof __VLS_36) => any;
+} & {
+    'loading-more'?: (props: typeof __VLS_39) => any;
+} & {
+    'load-more-error'?: (props: typeof __VLS_42) => any;
+} & {
+    end?: (props: typeof __VLS_45) => any;
+} & {
+    refreshing?: (props: typeof __VLS_48) => any;
+};
+declare const __VLS_base: 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>;
+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/runtime/table/components/DataList.vue

@@ -0,0 +1,56 @@
+<script setup>
+import DataListDefault from "./data-list/DataListDefault.vue";
+import DataListRoot from "./data-list/DataListRoot.vue";
+defineProps({
+  table: { type: Object, required: true },
+  title: { type: String, required: false },
+  description: { type: String, required: false },
+  height: { type: [String, Number], required: false },
+  locale: { type: Object, required: false },
+  density: { type: String, required: false },
+  ui: { type: Object, required: false }
+});
+</script>
+
+<template>
+  <DataListRoot :table="table" :locale="locale" :density="density" :ui="ui">
+    <DataListDefault :title="title" :description="description" :height="height">
+      <template v-if="$slots.title" #title>
+        <slot name="title" />
+      </template>
+      <template v-if="$slots.actions" #actions>
+        <slot name="actions" />
+      </template>
+      <template v-if="$slots.empty" #empty="scope">
+        <slot name="empty" v-bind="scope" />
+      </template>
+      <template v-if="$slots['empty-table']" #empty-table>
+        <slot name="empty-table" />
+      </template>
+      <template v-if="$slots['empty-grid']" #empty-grid>
+        <slot name="empty-grid" />
+      </template>
+      <template v-if="$slots.loading" #loading="scope">
+        <slot name="loading" v-bind="scope" />
+      </template>
+      <template v-if="$slots['initial-loading']" #initial-loading="scope">
+        <slot name="initial-loading" v-bind="scope" />
+      </template>
+      <template v-if="$slots.error" #error="scope">
+        <slot name="error" v-bind="scope" />
+      </template>
+      <template v-if="$slots['loading-more']" #loading-more="scope">
+        <slot name="loading-more" v-bind="scope" />
+      </template>
+      <template v-if="$slots['load-more-error']" #load-more-error="scope">
+        <slot name="load-more-error" v-bind="scope" />
+      </template>
+      <template v-if="$slots.end" #end="scope">
+        <slot name="end" v-bind="scope" />
+      </template>
+      <template v-if="$slots.refreshing" #refreshing>
+        <slot name="refreshing" />
+      </template>
+    </DataListDefault>
+  </DataListRoot>
+</template>

package/dist/runtime/table/components/DataList.vue.d.ts

@@ -0,0 +1,72 @@
+import type { ComputedRef } from 'vue';
+import type { UiToolsLocale, UiToolsMessages } from '#ui-tools/i18n';
+import type { TableInternals } from '../composables/use-table-internals.js';
+import type { DataListDensity, DataListUiConfig } from '../types/index.js';
+type DataListTable = {
+    schema: ComputedRef<{
+        tableKey: string;
+    }>;
+    __internals: TableInternals;
+};
+type __VLS_Props = {
+    table: DataListTable;
+    title?: string;
+    description?: string;
+    height?: string | number;
+    locale?: UiToolsLocale<UiToolsMessages>;
+    density?: DataListDensity;
+    ui?: DataListUiConfig;
+};
+declare var __VLS_15: {}, __VLS_18: {}, __VLS_21: {
+    layout: string;
+    refresh: () => void;
+}, __VLS_24: {}, __VLS_27: {}, __VLS_30: {
+    layout: "table" | "grid";
+}, __VLS_33: {
+    layout: "table" | "grid";
+}, __VLS_36: {
+    error: {};
+    retry: () => void;
+}, __VLS_39: {
+    loadedCount: number;
+}, __VLS_42: {
+    error: {};
+    retry: () => Promise<import("@tanstack/vue-query").InfiniteQueryObserverRefetchErrorResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverSuccessResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverLoadingErrorResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverPendingResult<unknown, unknown> | import("@tanstack/vue-query").InfiniteQueryObserverPlaceholderResult<unknown, unknown> | undefined>;
+}, __VLS_45: {
+    loadedCount: number;
+    totalCount: number | null;
+}, __VLS_48: {};
+type __VLS_Slots = {} & {
+    title?: (props: typeof __VLS_15) => any;
+} & {
+    actions?: (props: typeof __VLS_18) => any;
+} & {
+    empty?: (props: typeof __VLS_21) => any;
+} & {
+    'empty-table'?: (props: typeof __VLS_24) => any;
+} & {
+    'empty-grid'?: (props: typeof __VLS_27) => any;
+} & {
+    loading?: (props: typeof __VLS_30) => any;
+} & {
+    'initial-loading'?: (props: typeof __VLS_33) => any;
+} & {
+    error?: (props: typeof __VLS_36) => any;
+} & {
+    'loading-more'?: (props: typeof __VLS_39) => any;
+} & {
+    'load-more-error'?: (props: typeof __VLS_42) => any;
+} & {
+    end?: (props: typeof __VLS_45) => any;
+} & {
+    refreshing?: (props: typeof __VLS_48) => any;
+};
+declare const __VLS_base: 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>;
+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/runtime/table/components/actions/RowActions.d.vue.ts

@@ -0,0 +1,25 @@
+import type { DropdownMenuProps } from '@nuxt/ui';
+type __VLS_Props = {
+    content?: DropdownMenuProps['content'];
+    modal?: DropdownMenuProps['modal'];
+    portal?: DropdownMenuProps['portal'];
+    arrow?: DropdownMenuProps['arrow'];
+    disabled?: DropdownMenuProps['disabled'];
+    ui?: DropdownMenuProps['ui'];
+};
+declare var __VLS_9: {
+    items: import("@nuxt/ui").DropdownMenuItem[];
+    open: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_9) => any;
+};
+declare const __VLS_base: 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>;
+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/runtime/table/components/actions/RowActions.vue

@@ -0,0 +1,54 @@
+<script setup>
+import UDropdownMenu from "@nuxt/ui/components/DropdownMenu.vue";
+import { computed, useAttrs } from "vue";
+import { useTableInternals } from "../../composables/use-table-internals";
+import { useTableRowActionScope } from "../../composables/use-table-row-actions";
+import { createRowActionDropdownItems, resolveVisibleTableRowActions } from "../../utils";
+defineOptions({
+  inheritAttrs: false
+});
+const props = defineProps({
+  content: { type: Object, required: false },
+  modal: { type: Boolean, required: false },
+  portal: { type: [Boolean, String], required: false, skipCheck: true },
+  arrow: { type: [Boolean, Object], required: false },
+  disabled: { type: Boolean, required: false },
+  ui: { type: Object, required: false }
+});
+const attrs = useAttrs();
+const internals = useTableInternals();
+const scope = useTableRowActionScope();
+const portal = computed(() => props.portal ?? true);
+const visibleActions = computed(() => {
+  if (!scope?.value) return [];
+  return resolveVisibleTableRowActions({
+    schema: internals.schema.value,
+    scope: scope.value
+  });
+});
+const items = computed(() => {
+  if (!scope?.value) return [];
+  return createRowActionDropdownItems({
+    actions: visibleActions.value,
+    scope: scope.value
+  });
+});
+</script>
+
+<template>
+  <UDropdownMenu
+    v-if="scope && visibleActions.length && items.length"
+    :items="items"
+    :content="props.content"
+    :modal="props.modal"
+    :portal="portal"
+    :arrow="props.arrow"
+    :disabled="props.disabled"
+    :ui="props.ui"
+    v-bind="attrs"
+  >
+    <template #default="slotProps">
+      <slot v-bind="slotProps" :items="items" />
+    </template>
+  </UDropdownMenu>
+</template>

package/dist/runtime/table/components/actions/RowActions.vue.d.ts

@@ -0,0 +1,25 @@
+import type { DropdownMenuProps } from '@nuxt/ui';
+type __VLS_Props = {
+    content?: DropdownMenuProps['content'];
+    modal?: DropdownMenuProps['modal'];
+    portal?: DropdownMenuProps['portal'];
+    arrow?: DropdownMenuProps['arrow'];
+    disabled?: DropdownMenuProps['disabled'];
+    ui?: DropdownMenuProps['ui'];
+};
+declare var __VLS_9: {
+    items: import("@nuxt/ui").DropdownMenuItem[];
+    open: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_9) => any;
+};
+declare const __VLS_base: 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>;
+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;
+    };
+};