@bitrix24/b24ui-nuxt 0.5.11 → 0.6.1

package/dist/runtime/components/content/TableWrapper.vue.d.ts

@@ -0,0 +1,83 @@
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/b24ui/content/table-wrapper';
+import type { ComponentConfig } from '../../types/utils';
+type TableWrapper = ComponentConfig<typeof theme, AppConfig, 'tableWrapper', 'b24ui.content'>;
+export interface TableWrapperProps {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    /**
+     * @defaultValue 'md'
+     */
+    size?: TableWrapper['variants']['size'];
+    /**
+     * @defaultValue false
+     */
+    rounded?: boolean;
+    /**
+     * @defaultValue false
+     */
+    zebra?: boolean;
+    /**
+     * @defaultValue false
+     */
+    pinRows?: boolean;
+    /**
+     * @defaultValue false
+     */
+    pinCols?: boolean;
+    /**
+     * @defaultValue false
+     */
+    rowHover?: boolean;
+    /**
+     * @defaultValue false
+     */
+    bordered?: boolean;
+    /**
+     * @defaultValue true
+     */
+    scrollbarThin?: boolean;
+    class?: any;
+    b24ui?: TableWrapper['slots'];
+}
+export interface TableWrapperSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<TableWrapperProps>, {
+    as: string;
+    scrollbarThin: boolean;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<TableWrapperProps>, {
+    as: string;
+    scrollbarThin: boolean;
+}>>> & Readonly<{}>, {
+    as: any;
+    scrollbarThin: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/runtime/composables/useAvatarGroup.d.ts

@@ -6,5 +6,5 @@ export declare const avatarGroupInjectionKey: InjectionKey<ComputedRef<{
 export declare function useAvatarGroup(props: {
     size: AvatarGroupProps['size'];
 }): {
-    size: ComputedRef<any>;
+    size: ComputedRef<"md" | "3xs" | "2xs" | "xs" | "sm" | "lg" | "xl" | "2xl" | "3xl" | undefined>;
 };

package/dist/runtime/composables/useButtonGroup.d.ts

@@ -10,8 +10,8 @@ type Props<T> = {
     size?: GetObjectField<T, 'size'>;
 };
 export declare function useButtonGroup<T>(props: Props<T>): {
-    orientation: ComputedRef<any>;
-    size: ComputedRef<any>;
+    orientation: ComputedRef<"horizontal" | "vertical" | undefined>;
+    size: ComputedRef<"md" | "xs" | "sm" | "lg" | NonNullable<GetObjectField<T, "size">> | undefined>;
     noSplit: ComputedRef<boolean>;
 };
 export {};

package/dist/runtime/composables/useComponentIcons.d.ts

@@ -20,8 +20,8 @@ export interface UseComponentIconsProps {
     trailingIcon?: IconComponent;
 }
 export declare function useComponentIcons(componentProps: MaybeRefOrGetter<UseComponentIconsProps>): {
-    isLeading: import("vue").ComputedRef<any>;
+    isLeading: import("vue").ComputedRef<true | AvatarProps | undefined>;
     isTrailing: import("vue").ComputedRef<boolean>;
-    leadingIconName: import("vue").ComputedRef<IconComponent | undefined>;
-    trailingIconName: import("vue").ComputedRef<IconComponent | undefined>;
+    leadingIconName: import("vue").ComputedRef<import("vue").FunctionalComponent<import("vue").HTMLAttributes & import("vue").VNodeProps, {}, any, {}> | undefined>;
+    trailingIconName: import("vue").ComputedRef<import("vue").FunctionalComponent<import("vue").HTMLAttributes & import("vue").VNodeProps, {}, any, {}> | undefined>;
 };

package/dist/runtime/composables/useFormField.d.ts

@@ -26,12 +26,12 @@ export declare function useFormField<T>(props?: Props<T>, opts?: {
 }): {
     id: ComputedRef<string | undefined>;
     name: ComputedRef<string | undefined>;
-    size: ComputedRef<any>;
+    size: ComputedRef<"md" | "xs" | "sm" | "lg" | NonNullable<GetObjectField<T, "size">> | undefined>;
     color: ComputedRef<"danger" | GetObjectField<T, "color"> | undefined>;
     highlight: ComputedRef<boolean | undefined>;
     disabled: ComputedRef<boolean | undefined>;
     emitFormBlur: () => void;
-    emitFormInput: import("@vueuse/core").PromisifyFn<() => void>;
+    emitFormInput: import("@vueuse/core").UseDebounceFnReturn<() => void>;
     emitFormChange: () => void;
     emitFormFocus: () => void;
     ariaAttrs: ComputedRef<{

package/dist/runtime/composables/useOverlay.d.ts

@@ -6,22 +6,29 @@ export type OverlayOptions<OverlayAttrs = Record<string, any>> = {
     props?: OverlayAttrs;
     destroyOnClose?: boolean;
 };
-type ManagedOverlayOptionsPrivate<T extends Component> = {
+interface ManagedOverlayOptionsPrivate<T extends Component> {
     component?: T;
     id: symbol;
     isMounted: boolean;
-    modelValue: boolean;
-    resolvePromise?: (value: unknown) => void;
-};
+    isOpen: boolean;
+    resolvePromise?: (value: any) => void;
+}
 export type Overlay = OverlayOptions<Component> & ManagedOverlayOptionsPrivate<Component>;
-interface OverlayInstance<T> {
-    open: (props?: ComponentProps<T>) => Promise<CloseEventArgType<ComponentEmit<T>>>;
+interface OverlayInstance<T extends Component> extends Omit<ManagedOverlayOptionsPrivate<T>, 'component'> {
+    id: symbol;
+    result: Promise<CloseEventArgType<ComponentEmit<T>>>;
+    open: (props?: ComponentProps<T>) => Omit<OverlayInstance<T>, 'open' | 'close' | 'patch' | 'modelValue' | 'resolvePromise'>;
     close: (value?: any) => void;
     patch: (props: Partial<ComponentProps<T>>) => void;
 }
 declare function _useOverlay(): {
     overlays: import("vue").ShallowReactive<Overlay[]>;
-    open: <T extends Component>(id: symbol, props?: ComponentProps<T>) => Promise<any>;
+    open: <T extends Component>(id: symbol, props?: ComponentProps<T>) => {
+        id: symbol;
+        isMounted: boolean;
+        isOpen: boolean;
+        result: Promise<any>;
+    };
     close: (id: symbol, value?: any) => void;
     create: <T extends Component>(component: T, _options?: OverlayOptions<ComponentProps<T>>) => OverlayInstance<T>;
     patch: <T extends Component>(id: symbol, props: Partial<ComponentProps<T>>) => void;

package/dist/runtime/composables/useOverlay.js

@@ -6,7 +6,7 @@ function _useOverlay() {
     const { props, defaultOpen, destroyOnClose } = _options || {};
     const options = reactive({
       id: Symbol(import.meta.dev ? "useOverlay" : ""),
-      modelValue: !!defaultOpen,
+      isOpen: !!defaultOpen,
       component: markRaw(component),
       isMounted: !!defaultOpen,
       destroyOnClose: !!destroyOnClose,
@@ -14,6 +14,9 @@ function _useOverlay() {
     });
     overlays.push(options);
     return {
+      ...options,
+      result: new Promise(() => {
+      }),
       open: (props2) => open(options.id, props2),
       close: (value) => close(options.id, value),
       patch: (props2) => patch(options.id, props2)
@@ -24,15 +27,20 @@ function _useOverlay() {
     if (props) {
       patch(overlay.id, props);
     }
-    overlay.modelValue = true;
+    overlay.isOpen = true;
     overlay.isMounted = true;
-    return new Promise((resolve) => {
-      overlay.resolvePromise = resolve;
-    });
+    return {
+      id,
+      isMounted: overlay.isMounted,
+      isOpen: overlay.isOpen,
+      result: new Promise((resolve) => {
+        overlay.resolvePromise = resolve;
+      })
+    };
   };
   const close = (id, value) => {
     const overlay = getOverlay(id);
-    overlay.modelValue = false;
+    overlay.isOpen = false;
     if (overlay.resolvePromise) {
       overlay.resolvePromise(value);
       overlay.resolvePromise = void 0;

package/dist/runtime/prose/A.vue

@@ -1,32 +1,22 @@
-<script lang="ts">
-import type { AppConfig } from '@nuxt/schema'
-import _appConfig from '#build/app.config'
-import theme from '#build/b24ui/prose/a'
-import { tv } from '../utils/tv'
-
-const appConfigProseA = _appConfig as AppConfig & { b24ui: { prose: { a: Partial<typeof theme> } } }
-
-const proseA = tv({ extend: tv(theme), ...(appConfigProseA.b24ui?.prose?.a || {}) })
-
-export interface proseAProps {
-  class?: any
-  b24ui?: Partial<typeof proseA.slots>
-}
-
-export interface proseASlots {
-  default(props?: {}): any
-}
+<script>
+import theme from "#build/b24ui/prose/a";
 </script>
 
-<script setup lang="ts">
-const props = defineProps<proseAProps>()
-
-// eslint-disable-next-line vue/no-dupe-keys
-const b24ui = proseA({})
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../utils/tv";
+const props = defineProps({
+  class: { type: null, required: false },
+  b24ui: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const b24ui = computed(() => tv({ extend: tv(theme), ...appConfig.b24ui?.prose?.a || {} })());
 </script>
 
 <template>
-  <a
-    :class="b24ui.base({ class: [props.class, props.b24ui?.base] })"
-  ><slot /></a>
+  <a :class="b24ui.base({ class: [props.class, props.b24ui?.base] })">
+    <slot />
+  </a>
 </template>

package/dist/runtime/prose/A.vue.d.ts

@@ -0,0 +1,27 @@
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/b24ui/prose/a';
+import type { ComponentConfig } from '../types/utils';
+type ProseA = ComponentConfig<typeof theme, AppConfig, 'a', 'b24ui.prose'>;
+export interface ProseAProps {
+    class?: any;
+    b24ui?: ProseA['slots'];
+}
+export interface ProseASlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<ProseAProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<ProseAProps>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, Readonly<ProseASlots> & ProseASlots>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/prose/Blockquote.vue

@@ -1,34 +1,22 @@
-<script lang="ts">
-import type { AppConfig } from '@nuxt/schema'
-import _appConfig from '#build/app.config'
-import theme from '#build/b24ui/prose/blockquote'
-import { tv } from '../utils/tv'
-
-const appConfigProseBlockquote = _appConfig as AppConfig & { b24ui: { prose: { blockquote: Partial<typeof theme> } } }
-
-const proseBlockquote = tv({ extend: tv(theme), ...(appConfigProseBlockquote.b24ui?.prose?.blockquote || {}) })
-
-export interface proseBlockquoteProps {
-  class?: any
-  b24ui?: Partial<typeof proseBlockquote.slots>
-}
-
-export interface proseBlockquoteSlots {
-  default(props?: {}): any
-}
+<script>
+import theme from "#build/b24ui/prose/blockquote";
 </script>
 
-<script setup lang="ts">
-const props = defineProps<proseBlockquoteProps>()
-
-// eslint-disable-next-line vue/no-dupe-keys
-const b24ui = proseBlockquote({})
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../utils/tv";
+const props = defineProps({
+  class: { type: null, required: false },
+  b24ui: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const b24ui = computed(() => tv({ extend: tv(theme), ...appConfig.b24ui?.prose?.blockquote || {} })());
 </script>
 
 <template>
-  <blockquote
-    :class="b24ui.base({ class: [props.class, props.b24ui?.base] })"
-  >
+  <blockquote :class="b24ui.base({ class: [props.class, props.b24ui?.base] })">
     <slot />
   </blockquote>
 </template>

package/dist/runtime/prose/Blockquote.vue.d.ts

@@ -0,0 +1,27 @@
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/b24ui/prose/blockquote';
+import type { ComponentConfig } from '../types/utils';
+type ProseBlockquote = ComponentConfig<typeof theme, AppConfig, 'blockquote', 'b24ui.prose'>;
+export interface ProseBlockquoteProps {
+    class?: any;
+    b24ui?: ProseBlockquote['slots'];
+}
+export interface ProseBlockquoteSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<ProseBlockquoteProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<ProseBlockquoteProps>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, Readonly<ProseBlockquoteSlots> & ProseBlockquoteSlots>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/prose/Code.vue

@@ -1,38 +1,21 @@
-<script lang="ts">
-import type { VariantProps } from 'tailwind-variants'
-import type { AppConfig } from '@nuxt/schema'
-import _appConfig from '#build/app.config'
-import theme from '#build/b24ui/prose/code'
-import { tv } from '../utils/tv'
-
-const appConfigProseCode = _appConfig as AppConfig & { b24ui: { prose: { code: Partial<typeof theme> } } }
-
-const proseCode = tv({ extend: tv(theme), ...(appConfigProseCode.b24ui?.prose?.code || {}) })
-
-type ProseCodeVariants = VariantProps<typeof proseCode>
-
-export interface proseCodeProps {
-  /**
-   * @defaultValue 'default'
-   */
-  color?: ProseCodeVariants['color']
-  class?: any
-  b24ui?: Partial<typeof proseCode.slots>
-}
-
-export interface proseCodeSlots {
-  default(props?: {}): any
-}
+<script>
+import theme from "#build/b24ui/prose/code";
 </script>
 
-<script setup lang="ts">
-import { computed } from 'vue'
-
-const props = defineProps<proseCodeProps>()
-
-const b24ui = computed(() => proseCode({
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../utils/tv";
+const props = defineProps({
+  color: { type: null, required: false },
+  class: { type: null, required: false },
+  b24ui: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const b24ui = computed(() => tv({ extend: tv(theme), ...appConfig.b24ui?.prose?.code || {} })({
   color: props.color
-}))
+}));
 </script>
 
 <template>

package/dist/runtime/prose/Code.vue.d.ts

@@ -0,0 +1,31 @@
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/b24ui/prose/code';
+import type { ComponentConfig } from '../types/utils';
+type ProseCode = ComponentConfig<typeof theme, AppConfig, 'code', 'b24ui.prose'>;
+export interface ProseCodeProps {
+    /**
+     * @defaultValue 'default'
+     */
+    color?: ProseCode['variants']['color'];
+    class?: any;
+    b24ui?: ProseCode['slots'];
+}
+export interface ProseCodeSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<ProseCodeProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<ProseCodeProps>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, Readonly<ProseCodeSlots> & ProseCodeSlots>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/prose/Em.vue

@@ -1,32 +1,22 @@
-<script lang="ts">
-import type { AppConfig } from '@nuxt/schema'
-import _appConfig from '#build/app.config'
-import theme from '#build/b24ui/prose/em'
-import { tv } from '../utils/tv'
-
-const appConfigProseEm = _appConfig as AppConfig & { b24ui: { prose: { em: Partial<typeof theme> } } }
-
-const proseEm = tv({ extend: tv(theme), ...(appConfigProseEm.b24ui?.prose?.em || {}) })
-
-export interface proseEmProps {
-  class?: any
-  b24ui?: Partial<typeof proseEm.slots>
-}
-
-export interface proseEmSlots {
-  default(props?: {}): any
-}
+<script>
+import theme from "#build/b24ui/prose/em";
 </script>
 
-<script setup lang="ts">
-const props = defineProps<proseEmProps>()
-
-// eslint-disable-next-line vue/no-dupe-keys
-const b24ui = proseEm({})
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../utils/tv";
+const props = defineProps({
+  class: { type: null, required: false },
+  b24ui: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const b24ui = computed(() => tv({ extend: tv(theme), ...appConfig.b24ui?.prose?.em || {} })());
 </script>
 
 <template>
-  <em
-    :class="b24ui.base({ class: [props.class, props.b24ui?.base] })"
-  ><slot /></em>
+  <em :class="b24ui.base({ class: [props.class, props.b24ui?.base] })">
+    <slot />
+  </em>
 </template>

package/dist/runtime/prose/Em.vue.d.ts

@@ -0,0 +1,27 @@
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/b24ui/prose/em';
+import type { ComponentConfig } from '../types/utils';
+type ProseEm = ComponentConfig<typeof theme, AppConfig, 'em', 'b24ui.prose'>;
+export interface ProseEmProps {
+    class?: any;
+    b24ui?: ProseEm['slots'];
+}
+export interface ProseEmSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<ProseEmProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<ProseEmProps>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, Readonly<ProseEmSlots> & ProseEmSlots>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/prose/H1.vue

@@ -1,34 +1,22 @@
-<script lang="ts">
-import type { AppConfig } from '@nuxt/schema'
-import _appConfig from '#build/app.config'
-import theme from '#build/b24ui/prose/h1'
-import { tv } from '../utils/tv'
-
-const appConfigProseH1 = _appConfig as AppConfig & { b24ui: { prose: { h1: Partial<typeof theme> } } }
-
-const proseH1 = tv({ extend: tv(theme), ...(appConfigProseH1.b24ui?.prose?.h1 || {}) })
-
-export interface proseH1Props {
-  class?: any
-  b24ui?: Partial<typeof proseH1.slots>
-}
-
-export interface proseH1Slots {
-  default(props?: {}): any
-}
+<script>
+import theme from "#build/b24ui/prose/h1";
 </script>
 
-<script setup lang="ts">
-const props = defineProps<proseH1Props>()
-
-// eslint-disable-next-line vue/no-dupe-keys
-const b24ui = proseH1({})
+<script setup>
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { tv } from "../utils/tv";
+const props = defineProps({
+  class: { type: null, required: false },
+  b24ui: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const b24ui = computed(() => tv({ extend: tv(theme), ...appConfig.b24ui?.prose?.h1 || {} })());
 </script>
 
 <template>
-  <h1
-    :class="b24ui.base({ class: [props.class, props.b24ui?.base] })"
-  >
+  <h1 :class="b24ui.base({ class: [props.class, props.b24ui?.base] })">
     <slot />
   </h1>
 </template>

package/dist/runtime/prose/H1.vue.d.ts

@@ -0,0 +1,27 @@
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/b24ui/prose/h1';
+import type { ComponentConfig } from '../types/utils';
+type ProseH1 = ComponentConfig<typeof theme, AppConfig, 'h1', 'b24ui.prose'>;
+export interface ProseH1Props {
+    class?: any;
+    b24ui?: ProseH1['slots'];
+}
+export interface ProseH1Slots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<ProseH1Props>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<ProseH1Props>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, Readonly<ProseH1Slots> & ProseH1Slots>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};