@nuxt/ui 3.3.2 → 4.0.0-alpha.0

package/dist/runtime/components/prose/Li.vue

@@ -0,0 +1,21 @@
+<script>
+import theme from "#build/ui/prose/li";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.li || {} }));
+</script>
+
+<template>
+  <li :class="ui({ class: props.class })">
+    <slot />
+  </li>
+</template>

package/dist/runtime/components/prose/Li.vue.d.ts

@@ -0,0 +1,13 @@
+export interface ProseLiProps {
+    class?: any;
+}
+export interface ProseLiSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProseLiProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseLiProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProseLiSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/Ol.vue

@@ -0,0 +1,21 @@
+<script>
+import theme from "#build/ui/prose/ol";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.ol || {} }));
+</script>
+
+<template>
+  <ol :class="ui({ class: props.class })">
+    <slot />
+  </ol>
+</template>

package/dist/runtime/components/prose/Ol.vue.d.ts

@@ -0,0 +1,13 @@
+export interface ProseOlProps {
+    class?: any;
+}
+export interface ProseOlSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProseOlProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseOlProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProseOlSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/P.vue

@@ -0,0 +1,21 @@
+<script>
+import theme from "#build/ui/prose/p";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.p || {} }));
+</script>
+
+<template>
+  <p :class="ui({ class: props.class })">
+    <slot />
+  </p>
+</template>

package/dist/runtime/components/prose/P.vue.d.ts

@@ -0,0 +1,13 @@
+export interface ProsePProps {
+    class?: any;
+}
+export interface ProsePSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProsePProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProsePProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProsePSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/Pre.vue

@@ -0,0 +1,56 @@
+<script>
+import theme from "#build/ui/prose/pre";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useClipboard } from "@vueuse/core";
+import { useAppConfig } from "#imports";
+import { useLocale } from "../../composables/useLocale";
+import { tv } from "../../utils/tv";
+import UCodeIcon from "./CodeIcon.vue";
+import UButton from "../Button.vue";
+const props = defineProps({
+  icon: { type: String, required: false },
+  code: { type: String, required: false },
+  language: { type: String, required: false },
+  filename: { type: String, required: false },
+  highlights: { type: Array, required: false },
+  hideHeader: { type: Boolean, required: false },
+  meta: { type: String, required: false },
+  class: { type: null, required: false },
+  ui: { type: null, required: false }
+});
+defineSlots();
+const { t } = useLocale();
+const { copy, copied } = useClipboard();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.pre || {} })());
+</script>
+
+<template>
+  <div :class="ui.root({ class: [props.ui?.root], filename: !!filename })">
+    <div v-if="filename && !hideHeader" :class="ui.header({ class: props.ui?.header })">
+      <UCodeIcon :icon="icon" :filename="filename" :class="ui.icon({ class: props.ui?.icon })" />
+
+      <span :class="ui.filename({ class: props.ui?.filename })">{{ filename }}</span>
+    </div>
+
+    <UButton
+      :icon="copied ? appConfig.ui.icons.copyCheck : appConfig.ui.icons.copy"
+      color="neutral"
+      variant="outline"
+      size="sm"
+      :aria-label="t('prose.pre.copy')"
+      :class="ui.copy({ class: props.ui?.copy })"
+      tabindex="-1"
+      @click="copy(props.code || '')"
+    />
+
+    <pre :class="ui.base({ class: [props.ui?.base, props.class] })" v-bind="$attrs"><slot /></pre>
+  </div>
+</template>
+
+<style>
+.shiki span.line{display:block}.shiki span.line.highlight{margin:0 -16px;padding:0 16px;@apply bg-(--ui-bg-accented)/50}
+</style>

package/dist/runtime/components/prose/Pre.vue.d.ts

@@ -0,0 +1,25 @@
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/prose/pre';
+import type { ComponentConfig } from '../../types/tv';
+type ProsePre = ComponentConfig<typeof theme, AppConfig, 'pre', 'ui.prose'>;
+export interface ProsePreProps {
+    icon?: string;
+    code?: string;
+    language?: string;
+    filename?: string;
+    highlights?: number[];
+    hideHeader?: boolean;
+    meta?: string;
+    class?: any;
+    ui?: ProsePre['slots'];
+}
+export interface ProsePreSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProsePreProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProsePreProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProsePreSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/Script.vue

@@ -0,0 +1,12 @@
+<script setup>
+defineProps({
+  src: { type: String, required: true }
+});
+const isDev = import.meta.dev;
+</script>
+
+<template>
+  <div v-if="isDev">
+    Rendering the <code>script</code> element is dangerous and is disabled by default. Consider implementing your own <code>ProseScript</code> element to have control over script rendering.
+  </div>
+</template>

package/dist/runtime/components/prose/Script.vue.d.ts

@@ -0,0 +1,5 @@
+type __VLS_Props = {
+    src: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, void, {}, {}, {}, 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/runtime/components/prose/Steps.vue

@@ -0,0 +1,22 @@
+<script>
+import theme from "#build/ui/prose/steps";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  level: { type: null, required: false },
+  class: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.steps || {} }));
+</script>
+
+<template>
+  <div :class="ui({ class: props.class, level: props.level })">
+    <slot />
+  </div>
+</template>

package/dist/runtime/components/prose/Steps.vue.d.ts

@@ -0,0 +1,22 @@
+import type { AppConfig } from '@nuxt/schema';
+import type { ComponentConfig } from '../../types/tv';
+import theme from '#build/ui/prose/steps';
+type ProseSteps = ComponentConfig<typeof theme, AppConfig, 'steps', 'ui.prose'>;
+export interface ProseStepsProps {
+    /**
+     * The heading level to apply to the steps.
+     * @defaultValue '3'
+     */
+    level?: ProseSteps['variants']['level'];
+    class?: any;
+}
+export interface ProseStepsSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProseStepsProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseStepsProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProseStepsSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/Strong.vue

@@ -0,0 +1,21 @@
+<script>
+import theme from "#build/ui/prose/strong";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.strong || {} }));
+</script>
+
+<template>
+  <strong :class="ui({ class: props.class })">
+    <slot />
+  </strong>
+</template>

package/dist/runtime/components/prose/Strong.vue.d.ts

@@ -0,0 +1,13 @@
+export interface ProseStrongProps {
+    class?: any;
+}
+export interface ProseStrongSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProseStrongProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseStrongProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProseStrongSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/Table.vue

@@ -0,0 +1,24 @@
+<script>
+import theme from "#build/ui/prose/table";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  class: { type: null, required: false },
+  ui: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.table || {} })());
+</script>
+
+<template>
+  <div :class="ui.root({ class: [props.ui?.root, props.class] })">
+    <table :class="ui.base({ class: props.ui?.base })">
+      <slot />
+    </table>
+  </div>
+</template>

package/dist/runtime/components/prose/Table.vue.d.ts

@@ -0,0 +1,18 @@
+import type { AppConfig } from '@nuxt/schema';
+import type { ComponentConfig } from '../../types/tv';
+import theme from '#build/ui/prose/table';
+type ProseTable = ComponentConfig<typeof theme, AppConfig, 'table', 'ui.prose'>;
+export interface ProseTableProps {
+    class?: any;
+    ui?: ProseTable['slots'];
+}
+export interface ProseTableSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProseTableProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseTableProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProseTableSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/Tabs.vue

@@ -0,0 +1,79 @@
+<script>
+import theme from "#build/ui/prose/tabs";
+</script>
+
+<script setup>
+import { computed, watch, onMounted, ref, onBeforeUpdate } from "vue";
+import { useState, useAppConfig } from "#imports";
+import { transformUI } from "../../utils";
+import { tv } from "../../utils/tv";
+import UTabs from "../Tabs.vue";
+const props = defineProps({
+  defaultValue: { type: String, required: false, default: "0" },
+  sync: { type: String, required: false },
+  hash: { type: String, required: false },
+  class: { type: null, required: false }
+});
+const slots = defineSlots();
+const model = defineModel({ type: String });
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.tabs || {} }));
+const rerenderCount = ref(1);
+const items = computed(() => {
+  rerenderCount.value;
+  return slots.default?.()?.flatMap(transformSlot).filter(Boolean) || [];
+});
+function transformSlot(slot, index) {
+  if (typeof slot.type === "symbol") {
+    return slot.children?.map(transformSlot);
+  }
+  return {
+    index,
+    label: slot.props?.label || `${index}`,
+    description: slot.props?.description,
+    icon: slot.props?.icon,
+    component: slot
+  };
+}
+onMounted(() => {
+  if (props.sync) {
+    const syncKey = `tabs-${props.sync}`;
+    const syncValue = useState(syncKey, () => localStorage.getItem(syncKey));
+    watch(syncValue, () => {
+      if (!syncValue.value) return;
+      model.value = syncValue.value;
+    }, { immediate: true });
+    watch(model, () => {
+      if (!model.value) return;
+      syncValue.value = model.value;
+      localStorage.setItem(syncKey, model.value);
+    });
+  }
+});
+async function onUpdateModelValue() {
+  if (props.hash) {
+    const hash = props.hash.startsWith("#") ? props.hash : `#${props.hash}`;
+    setTimeout(() => {
+      document.querySelector(hash)?.scrollIntoView();
+    }, 200);
+  }
+}
+onBeforeUpdate(() => rerenderCount.value++);
+</script>
+
+<template>
+  <UTabs
+    v-model="model"
+    color="primary"
+    variant="link"
+    :items="items"
+    :class="props.class"
+    :unmount-on-hide="false"
+    :ui="transformUI(ui())"
+    @update:model-value="onUpdateModelValue"
+  >
+    <template #content="{ item }">
+      <component :is="item.component" />
+    </template>
+  </UTabs>
+</template>

package/dist/runtime/components/prose/Tabs.vue.d.ts

@@ -0,0 +1,36 @@
+export interface ProseTabsProps {
+    /**
+     * The default tab to select.
+     * @example '1'
+     */
+    defaultValue?: string;
+    /**
+     * Sync the selected tab with a local storage key.
+     */
+    sync?: string;
+    /**
+     * The hash to scroll to when the tab is selected.
+     */
+    hash?: string;
+    class?: any;
+}
+export interface ProseTabsSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProseTabsProps & {
+    modelValue?: string;
+}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<ProseTabsProps & {
+    modelValue?: string;
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
+}>, {
+    defaultValue: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProseTabsSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/TabsItem.vue

@@ -0,0 +1,25 @@
+<script>
+import theme from "#build/ui/prose/tabs-item";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  label: { type: String, required: true },
+  description: { type: String, required: false },
+  class: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.tabsItem || {} }));
+</script>
+
+<template>
+  <div :class="ui({ class: props.class })">
+    <slot>
+      {{ description }}
+    </slot>
+  </div>
+</template>

package/dist/runtime/components/prose/TabsItem.vue.d.ts

@@ -0,0 +1,15 @@
+export interface ProseTabsItemProps {
+    label: string;
+    description?: string;
+    class?: any;
+}
+export interface ProseTabsItemSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProseTabsItemProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseTabsItemProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProseTabsItemSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/Tbody.vue

@@ -0,0 +1,21 @@
+<script>
+import theme from "#build/ui/prose/tbody";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.tbody || {} }));
+</script>
+
+<template>
+  <tbody :class="ui({ class: props.class })">
+    <slot />
+  </tbody>
+</template>

package/dist/runtime/components/prose/Tbody.vue.d.ts

@@ -0,0 +1,13 @@
+export interface ProseTbodyProps {
+    class?: any;
+}
+export interface ProseTbodySlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProseTbodyProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseTbodyProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProseTbodySlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/Td.vue

@@ -0,0 +1,21 @@
+<script>
+import theme from "#build/ui/prose/td";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.td || {} }));
+</script>
+
+<template>
+  <td :class="ui({ class: props.class })">
+    <slot />
+  </td>
+</template>

package/dist/runtime/components/prose/Td.vue.d.ts

@@ -0,0 +1,13 @@
+export interface ProseTdProps {
+    class?: any;
+}
+export interface ProseTdSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProseTdProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseTdProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProseTdSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/Th.vue

@@ -0,0 +1,21 @@
+<script>
+import theme from "#build/ui/prose/th";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.th || {} }));
+</script>
+
+<template>
+  <th :class="ui({ class: props.class })">
+    <slot />
+  </th>
+</template>

package/dist/runtime/components/prose/Th.vue.d.ts

@@ -0,0 +1,13 @@
+export interface ProseThProps {
+    class?: any;
+}
+export interface ProseThSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProseThProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseThProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProseThSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/prose/Thead.vue

@@ -0,0 +1,21 @@
+<script>
+import theme from "#build/ui/prose/thead";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.prose?.thead || {} }));
+</script>
+
+<template>
+  <thead :class="ui({ class: props.class })">
+    <slot />
+  </thead>
+</template>

package/dist/runtime/components/prose/Thead.vue.d.ts

@@ -0,0 +1,13 @@
+export interface ProseTheadProps {
+    class?: any;
+}
+export interface ProseTheadSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ProseTheadProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProseTheadProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ProseTheadSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};