maz-ui 4.1.8-beta.1 → 4.1.8-beta.2

package/dist/components/MazAccordion.vue.d.ts

@@ -0,0 +1,36 @@
+export interface MazAccordionProps {
+    id?: string;
+    modelValue?: number;
+    contentClass?: unknown;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<`title-${number}`, (_: {
+        isOpen: boolean;
+    }) => any>> & Partial<Record<`content-${number}`, (_: {
+        isOpen: boolean;
+    }) => any>> & {
+        content?(_: {
+            isOpen: boolean;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<MazAccordionProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:model-value": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<MazAccordionProps> & Readonly<{
+    "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
+}>, {
+    id: string;
+    modelValue: number;
+    contentClass: undefined;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/MazAnimatedCounter.vue.d.ts

@@ -0,0 +1,59 @@
+export interface MazAnimatedCounterProps {
+    /**
+     * The number to animate
+     */
+    count: number;
+    /**
+     * Duration of the animation in milliseconds
+     * @default 1000
+     */
+    duration?: number;
+    /**
+     * Suffix to display next to the number
+     */
+    prefix?: string;
+    /**
+     * Suffix to display next to the number
+     */
+    suffix?: string;
+    /**
+     * Delay before the animation starts in milliseconds
+     * @default 100
+     */
+    delay?: number;
+    /**
+     * Play the animation only once
+     * @default true
+     */
+    once?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        prefix?(_: {}): any;
+        prefix?(_: {}): any;
+        suffix?(_: {}): any;
+        suffix?(_: {}): any;
+    };
+    refs: {
+        elementRef: HTMLSpanElement;
+    };
+    rootEl: HTMLSpanElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<MazAnimatedCounterProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<MazAnimatedCounterProps> & Readonly<{}>, {
+    duration: number;
+    delay: number;
+    once: boolean;
+    prefix: string;
+    suffix: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    elementRef: HTMLSpanElement;
+}, HTMLSpanElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/MazAnimatedElement.vue.d.ts

@@ -0,0 +1,44 @@
+export interface MazAnimatedElementProps {
+    /**
+     * The direction of the animation
+     * @default "up"
+     * @values "up", "down", "left", "right"
+     */
+    direction?: 'up' | 'down' | 'left' | 'right';
+    /**
+     * The delay of the animation
+     * @default 0
+     */
+    delay?: number;
+    /**
+     * The duration of the animation
+     * @default 2000
+     */
+    duration?: number;
+    /**
+     * Play the animation only once
+     * @default true
+     */
+    once?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        element: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<MazAnimatedElementProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<MazAnimatedElementProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    element: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/MazAnimatedText.vue.d.ts

@@ -0,0 +1,57 @@
+export interface MazAnimatedTextProps {
+    /**
+     * The text to animate
+     * @example "Hello"
+     */
+    text: string;
+    /**
+     * The last word(s) to be highlighted
+     * @example "world"
+     */
+    lastWord?: string;
+    /**
+     * The delay of the animation
+     * @default 0
+     */
+    delay?: number;
+    /**
+     * The direction of the animation
+     * @default "up"
+     * @values "up", "down", "left", "right"
+     */
+    direction?: 'up' | 'down' | 'left' | 'right';
+    /**
+     * The tag to use for the text
+     * @default "span"
+     */
+    tag?: string;
+    /**
+     * The delay between each word
+     * @default 75
+     */
+    wordDelay?: number;
+    /**
+     * The column gap between each word
+     * @default 0.5
+     */
+    columnGap?: number;
+    /**
+     * The row gap between each word
+     * @default 0
+     */
+    rowGap?: number;
+    /**
+     * The duration of the animation
+     * @default 2000
+     */
+    duration?: number;
+    /**
+     * Play the animation only once
+     * @default true
+     */
+    once?: boolean;
+}
+declare const _default: import('vue').DefineComponent<MazAnimatedTextProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<MazAnimatedTextProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    element: unknown;
+}, any>;
+export default _default;

package/dist/components/MazAvatar.vue.d.ts

@@ -0,0 +1,99 @@
+import { HTMLAttributes } from 'vue';
+import { MazColor } from './types';
+export interface MazAvatarProps {
+    /** The style of the component */
+    style?: HTMLAttributes['style'];
+    /** The class of the component */
+    class?: HTMLAttributes['class'];
+    /** The source of the image */
+    src?: string | null;
+    /** The caption of the avatar */
+    caption?: string | null;
+    /** The link of the avatar */
+    href?: string;
+    /** The link (router-link) of the avatar */
+    to?: string | Record<string, unknown>;
+    /** The alt of the image */
+    alt?: string;
+    /** The target of the link */
+    target?: string;
+    /** The size of the avatar */
+    size?: string;
+    /** Add a border to the avatar */
+    bordered?: boolean;
+    /** Make the avatar clickable */
+    clickable?: boolean;
+    /** Make the avatar square */
+    square?: boolean;
+    /** Remove the shadow */
+    noElevation?: boolean;
+    /** Show the caption */
+    showCaption?: boolean;
+    /** Make the image height full */
+    imageHeightFull?: boolean;
+    /** Remove the loader */
+    hideLoader?: boolean;
+    /** The color of the clickable button */
+    buttonColor?: MazColor;
+    /** Remove the icon on hover when component is clickable */
+    hideClickableIcon?: boolean;
+    /** Number of letters to display in the round text */
+    letterCount?: number;
+    /**
+     * Size of the rounded
+     * @values `'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full'`
+     */
+    roundedSize?: 'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
+    /** The fallback src to replace the src on loading error */
+    fallbackSrc?: string;
+    /**
+     * The loading strategy of the image - lazy, eager or intersecting
+     * @default 'intersecting'
+     * @values `'lazy' | 'eager' | 'intersecting'`
+     */
+    loading?: 'lazy' | 'eager' | 'intersecting';
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'round-text'?(_: {}): any;
+        icon?(_: {}): any;
+        caption?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<MazAvatarProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    click: (event: MouseEvent) => any;
+    error: (el: Element) => any;
+    loaded: (el: Element) => any;
+    loading: (el: Element) => any;
+    intersecting: (el: Element) => any;
+}, string, import('vue').PublicProps, Readonly<MazAvatarProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+    onError?: ((el: Element) => any) | undefined;
+    onLoaded?: ((el: Element) => any) | undefined;
+    onLoading?: ((el: Element) => any) | undefined;
+    onIntersecting?: ((el: Element) => any) | undefined;
+}>, {
+    src: string | null;
+    size: string;
+    caption: string | null;
+    roundedSize: "none" | "sm" | "md" | "lg" | "xl" | "full";
+    loading: "lazy" | "eager" | "intersecting";
+    href: string;
+    to: string | Record<string, unknown>;
+    target: string;
+    alt: string;
+    fallbackSrc: string;
+    buttonColor: MazColor;
+    letterCount: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/MazBackdrop.vue.d.ts

@@ -0,0 +1,91 @@
+import { HTMLAttributes } from 'vue';
+export interface MazBackdropProps {
+    /** @model Modal's model value */
+    modelValue?: boolean;
+    /** Teleport selector */
+    teleportSelector?: string;
+    /** Function called before modal is close */
+    beforeClose?: () => Promise<void> | void;
+    /** Persistent dialog (not closable by clicking outside and remove close button) */
+    persistent?: boolean;
+    /** Prevent close on escape key */
+    closeOnEscape?: boolean;
+    /** Transition name */
+    transitionName?: string;
+    /** Backdrop class */
+    backdropClass?: HTMLAttributes['class'];
+    /** Backdrop content class */
+    backdropContentClass?: HTMLAttributes['class'];
+    /** Add padding to the content */
+    contentPadding?: boolean;
+    /** Justify content */
+    justify?: 'center' | 'end' | 'start' | 'space-between' | 'space-around' | 'none';
+    /** Align content */
+    align?: 'center' | 'end' | 'start' | 'none';
+    /** Variant */
+    variant?: 'bottom-sheet' | 'dialog' | 'drawer';
+    /** ID for aria-labelledby */
+    ariaLabelledby?: string;
+    /** ID for aria-describedby */
+    ariaDescribedby?: string;
+}
+declare function close(): void;
+declare function toggleModal(value?: boolean): Promise<void>;
+declare function onBackdropAnimationLeave(): void;
+declare function onKeyPress(event: KeyboardEvent): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            close: typeof close;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<MazBackdropProps, {
+    /**
+     * Animation leave event
+     * @description This is used to handle animation leave events
+     */
+    onBackdropAnimationLeave: typeof onBackdropAnimationLeave;
+    /**
+     * Close the backdrop
+     * @description This is used to close the backdrop
+     */
+    close: typeof close;
+    /**
+     * The present state of the backdrop
+     * @description This is used to check if the backdrop is present (open)
+     */
+    present: import('vue').Ref<boolean, boolean>;
+    /**
+     * Toggle the backdrop
+     * @description This is used to toggle the backdrop
+     * @param {boolean} value - The value to toggle the backdrop (optional)
+     */
+    toggleModal: typeof toggleModal;
+    /**
+     * Key press event
+     * @description This is used to handle key press events
+     */
+    onKeyPress: typeof onKeyPress;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: (value: void) => any;
+    open: (value: void) => any;
+    "update:model-value": (value: boolean) => any;
+    "before-close": (value: void) => any;
+}, string, import('vue').PublicProps, Readonly<MazBackdropProps> & Readonly<{
+    onClose?: ((value?: void | undefined) => any) | undefined;
+    onOpen?: ((value?: void | undefined) => any) | undefined;
+    "onUpdate:model-value"?: ((value: boolean) => any) | undefined;
+    "onBefore-close"?: ((value?: void | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/MazBadge.vue.d.ts

@@ -0,0 +1,61 @@
+import { MazColor } from './types';
+export type MazBadgeColor = MazColor | 'background';
+export type MazBadgeRoundedSize = 'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
+export interface MazBadgeProps {
+    /**
+     * Color of the badge
+     * @values `'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'destructive' | 'contrast' | 'background'`
+     * @default primary
+     */
+    color?: MazBadgeColor;
+    /**
+     * Size of the badge
+     * @default 0.8em
+     */
+    size?: string;
+    /**
+     * Will not wrap the text
+     * @default false
+     */
+    nowrap?: boolean;
+    /**
+     * Will add a border to the badge
+     * @default false
+     */
+    outlined?: boolean;
+    /**
+     * Will add a pastel style to the badge
+     * @default false
+     */
+    pastel?: boolean;
+    /**
+     * Size radius of the component's border
+     * @values `'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full'`
+     * @default md
+     */
+    roundedSize?: MazBadgeRoundedSize;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLSpanElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<MazBadgeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<MazBadgeProps> & Readonly<{}>, {
+    size: string;
+    color: MazBadgeColor;
+    roundedSize: MazBadgeRoundedSize;
+    outlined: boolean;
+    pastel: boolean;
+    nowrap: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/MazBottomSheet.vue.d.ts

@@ -0,0 +1,35 @@
+export interface MazBottomSheetProps {
+    /** @model Modal's model value */
+    modelValue?: boolean;
+    /** Remove the close button */
+    hideCloseButton?: boolean;
+    /** Remove the padding on the container */
+    padding?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            close: () => void;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<MazBottomSheetProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: (value: void) => any;
+    open: (value: void) => any;
+    "update:model-value": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<MazBottomSheetProps> & Readonly<{
+    onClose?: ((value?: void | undefined) => any) | undefined;
+    onOpen?: ((value?: void | undefined) => any) | undefined;
+    "onUpdate:model-value"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/MazBtn.vue.d.ts

@@ -0,0 +1,105 @@
+import { IconComponent } from '@maz-ui/icons';
+import { MazColor, MazSize } from './types';
+export interface MazBtnProps {
+    /**
+     * The text of the button, if not provided, the slot will be used
+     * @default undefined
+     */
+    text?: string;
+    /**
+     * The size of the button
+     * @values `'xl' | 'lg' | 'md' | 'sm' | 'xs' | 'mini'`
+     */
+    size?: MazSize;
+    /**
+     * The color of the button
+     * @values `'primary' | 'secondary' | 'info' | 'success' | 'warning' | 'destructive' | 'transparent' | 'contrast' | 'accent' | 'background'`
+     */
+    color?: MazColor | 'background';
+    /**
+     * The type of the button
+     * @values `'submit' | 'reset' | 'button'`
+     */
+    type?: 'submit' | 'reset' | 'button';
+    /**
+     * Size of the rounded
+     * @values `'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full'`
+     * @default 'lg'
+     */
+    roundedSize?: 'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
+    /**
+     * If true, the button have the "border" style
+     * @default false
+     */
+    outlined?: boolean;
+    /**
+     * If true, the button will have a pastel color
+     * @default false
+     */
+    pastel?: boolean;
+    /**
+     * If true, the button will have a full width
+     * @default false
+     */
+    block?: boolean;
+    /**
+     * Enable the button loader
+     * @default false
+     */
+    loading?: boolean;
+    /**
+     * Disable the button
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * If true, the button will have a fab style
+     * @default false
+     */
+    fab?: boolean;
+    /**
+     * The name of the icon to display or component, only with fab
+     * `@type` `{string | FunctionalComponent<SVGAttributes> | ComponentPublicInstance | Component}`
+     */
+    icon?: string | IconComponent;
+    /**
+     * The name of the icon or component to display on the left of the button
+     * `@type` `{string | FunctionalComponent<SVGAttributes> | ComponentPublicInstance | Component}`
+     */
+    leftIcon?: string | IconComponent;
+    /**
+     * The name of the icon or component to display on the right of the button
+     * `@type` `{string | FunctionalComponent<SVGAttributes> | ComponentPublicInstance | Component}`
+     */
+    rightIcon?: string | IconComponent;
+    /**
+     * If true, the button will have no padding
+     * @default true
+     */
+    padding?: boolean;
+    /**
+     * Choose how the elements are aligned in the button
+     */
+    justify?: 'start' | 'end' | 'center' | 'space-between' | 'space-around' | 'space-evenly';
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'left-icon'?(_: {}): any;
+        icon?(_: {}): any;
+        default?(_: {}): any;
+        'right-icon'?(_: {}): any;
+        loader?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<MazBtnProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<MazBtnProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/MazCard.vue.d.ts

@@ -0,0 +1,81 @@
+import { HTMLAttributes } from 'vue';
+import { RouterLinkProps } from 'vue-router';
+import { MazGalleryProps } from './MazGallery.vue';
+type __VLS_Props = MazCardProps;
+export interface MazCardProps {
+    /** Card variant: Must be `column | row | row-reverse | column-reverse` */
+    orientation?: 'column' | 'row' | 'row-reverse' | 'column-reverse';
+    /** Make card a link (footer area excluded) */
+    href?: string;
+    /** Make card a link with a router-link (footer area excluded) */
+    to?: RouterLinkProps['to'];
+    /** Target option of link: Muse be one of `_blank | _self | _parent | _top | framename` */
+    hrefTarget?: '_blank' | '_self' | '_parent' | '_top' | string;
+    /** Footer text alignment: `right | left` */
+    footerAlign?: 'right' | 'left';
+    /**
+     * Images gallery props options (see `MazGallery` component)
+     * @default `{ displayedCount: 3, remaining: false, zoom: !href && !to, width: 200, height: 150 }`
+     * If `href` or `to` is set, `zoom` is set to `false`
+     */
+    gallery?: MazGalleryProps;
+    /** scale animation on hover (only linked cards) */
+    scale?: boolean;
+    /** Set elevation to card (box-shadow) */
+    elevation?: boolean;
+    /** Set radius to card */
+    radius?: boolean;
+    /** Set border to card (in dark mode, the card is always bordered) */
+    bordered?: boolean;
+    /** add classes to wrapper */
+    wrapperClass?: HTMLAttributes['class'];
+    /** Remove padding from content wrapper */
+    padding?: boolean;
+    /** Hide overflow */
+    overflowHidden?: boolean;
+    /** Make card collapsible */
+    collapsible?: boolean;
+    /**
+     * Card is open by default if `true`
+     * @model
+     */
+    collapseOpen?: boolean;
+    /** Title of the card in header */
+    title?: string;
+    /** The card will be displayed in full width */
+    block?: boolean;
+}
+type __VLS_PublicProps = {
+    'collapseOpen'?: boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        title?(_: {}): any;
+        'content-title'?(_: {
+            collapseOpen: boolean;
+        }): any;
+        'content-subtitle'?(_: {}): any;
+        'content-body'?(_: {}): any;
+        default?(_: {
+            collapseOpen: boolean;
+        }): any;
+        footer?(_: {}): any;
+        actions?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:collapseOpen": (...args: unknown[]) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:collapseOpen"?: ((...args: unknown[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};