import { AllowedComponentProps } from 'vue';
import { AnchorHTMLAttributes } from 'vue';
import { ArrowOptions } from '@floating-ui/vue';
import { ButtonHTMLAttributes } from 'vue';
import { Component } from 'vue';
import { ComponentCustomProperties } from 'vue';
import { ComponentCustomProps } from 'vue';
import { ComponentInternalInstance } from 'vue';
import { ComponentOptionsBase } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { ComponentPublicInstance } from 'vue';
import { Coords } from '@floating-ui/vue';
import { CreateComponentPublicInstanceWithMixins } from 'vue';
import { DebuggerEvent } from 'vue';
import { DefineComponent } from 'vue';
import { DrawerDirection } from 'vaul-vue';
import { FloatingArrowProps } from './floatingArrow/FloatingArrow';
import { GlobalComponents } from 'vue';
import { GlobalDirectives } from 'vue';
import { ImgHTMLAttributes } from 'vue';
import { InputHTMLAttributes } from 'vue';
import { LabelHTMLAttributes } from 'vue';
import { LiHTMLAttributes } from 'vue';
import { MaybeElement } from '@floating-ui/vue';
import { MaybeRef } from 'vue';
import { Middleware } from '@floating-ui/vue';
import { nextTick } from 'vue';
import { OnCleanup } from '@vue/reactivity';
import { Placement } from '@floating-ui/vue';
import { PublicProps } from 'vue';
import { ReferenceElement } from '@floating-ui/vue';
import { SelectHTMLAttributes } from 'vue';
import { ShallowUnwrapRef } from 'vue';
import { Slot } from 'vue';
import { TextareaHTMLAttributes } from 'vue';
import { UnwrapRef } from 'vue';
import { VisuallyHiddenProps as VisuallyHiddenProps_2 } from '../../service';
import { VNode } from 'vue';
import { VNodeProps } from 'vue';
import { WatchOptions } from 'vue';
import { WatchStopHandle } from 'vue';

declare const __VLS_component: DefineComponent<AvatarProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AvatarProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_10: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLElement>;

declare const __VLS_component_11: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLElement>;

declare const __VLS_component_12: DefineComponent<SectionHeaderProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SectionHeaderProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;

declare const __VLS_component_13: DefineComponent<SectionFooterProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SectionFooterProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;

declare const __VLS_component_14: DefineComponent<TimelineProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TimelineProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_15: DefineComponent<TimelineItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TimelineItemProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLLIElement>;

declare const __VLS_component_16: DefineComponent<ButtonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ButtonProps> & Readonly<{}>, {
is: Component | string;
size: "s" | "m" | "l";
mode: "filled" | "bezeled" | "plain" | "gray" | "outline" | "white";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_17: DefineComponent<CellProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<CellProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_18: DefineComponent<InfoProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<InfoProps> & Readonly<{}>, {
type: "text" | "avatarStack";
subtitle: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_19: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;

declare const __VLS_component_2: DefineComponent<AvatarBadgeProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AvatarBadgeProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_20: DefineComponent<ButtonCellProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ButtonCellProps> & Readonly<{}>, {
is: Component | string;
mode: "default" | "destructive";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_21: DefineComponent<BannerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
close: () => any;
}, string, PublicProps, Readonly<BannerProps> & Readonly<{
onClose?: (() => any) | undefined;
}>, {
type: "section" | "inline";
showCloseIcon: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;

declare const __VLS_component_22: DefineComponent<CardProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<CardProps> & Readonly<{}>, {
type: CardInjection["type"];
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;

declare const __VLS_component_23: DefineComponent<CardCellProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<CardCellProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_24: DefineComponent<CardChipProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<CardChipProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_25: DefineComponent<IconButtonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<IconButtonProps> & Readonly<{}>, {
size: "s" | "m" | "l";
mode: "bezeled" | "plain" | "gray" | "outline";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_26: DefineComponent<AccordionProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
change: (expanded: boolean) => any;
}, string, PublicProps, Readonly<AccordionProps> & Readonly<{
onChange?: ((expanded: boolean) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_27: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {
body: HTMLDivElement;
}, HTMLDivElement>;

declare const __VLS_component_28: DefineComponent<AccordionSummaryProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AccordionSummaryProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_29: DefineComponent<InlineButtonsItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<InlineButtonsItemProps> & Readonly<{}>, {
text: string;
mode: "plain" | "gray" | "bezeled";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_3: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;

declare const __VLS_component_30: DefineComponent<InlineButtonsProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<InlineButtonsProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_31: DefineComponent<SkeletonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SkeletonProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_32: DefineComponent<SpoilerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SpoilerProps> & Readonly<{}>, {
visible: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_33: DefineComponent<SnackbarButtonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SnackbarButtonProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_34: DefineComponent<ChipProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ChipProps> & Readonly<{}>, {
is: Component | string;
mode: "elevated" | "mono" | "outline";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_35: DefineComponent<FileInputProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<FileInputProps> & Readonly<{}>, {
label: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_36: DefineComponent<FixedLayoutProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<FixedLayoutProps> & Readonly<{}>, {
is: Component | string;
vertical: "top" | "bottom";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_37: DefineComponent<TabbarItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TabbarItemProps> & Readonly<{}>, {
selected: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_38: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const __VLS_component_39: DefineComponent<BreadcrumbsProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<BreadcrumbsProps> & Readonly<{}>, {
divider: "dot" | "slash" | "chevron";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_4: DefineComponent<BadgeProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<BadgeProps> & Readonly<{}>, {
large: boolean;
mode: "primary" | "critical" | "secondary" | "gray" | "white";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLSpanElement>;

declare const __VLS_component_40: DefineComponent<BreadcrumbsItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<BreadcrumbsItemProps> & Readonly<{}>, {
is: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_41: DefineComponent<CompactPaginationProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<CompactPaginationProps> & Readonly<{}>, {
mode: "default" | "ambient" | "white";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_42: DefineComponent<CompactPaginationItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<CompactPaginationItemProps> & Readonly<{}>, {
selected: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLButtonElement>;

declare const __VLS_component_43: DefineComponent<LinkProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<LinkProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLAnchorElement>;

declare const __VLS_component_44: DefineComponent<TabsListItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TabsListItemProps> & Readonly<{}>, {
selected: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_45: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;

declare const __VLS_component_46: DefineComponent<SegmentedControlItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SegmentedControlItemProps> & Readonly<{}>, {
selected: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_47: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;

declare const __VLS_component_48: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const __VLS_component_49: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLElement>;

declare const __VLS_component_5: DefineComponent<BlockquoteProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<BlockquoteProps> & Readonly<{}>, {
type: "text" | "other";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_50: DefineComponent<TooltipProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TooltipProps> & Readonly<{}>, {
mode: "light" | "dark";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_51: DefineComponent<HorizontalScrollProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<HorizontalScrollProps> & Readonly<{}>, {
is: Component | string | number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_52: DefineComponent<VisuallyHiddenProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<VisuallyHiddenProps> & Readonly<{}>, {
is: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_53: DefineComponent<AppRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AppRootProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
appRoot: HTMLDivElement;
}, HTMLDivElement>;

declare const __VLS_component_54: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const __VLS_component_55: DefineComponent<TappableProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TappableProps> & Readonly<{}>, {
is: Component | string;
interactiveAnimation: "opacity" | "background";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_56: DefineComponent<CaptionProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<CaptionProps> & Readonly<{}>, {
level: CaptionLevel;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_57: DefineComponent<HeadlineProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<HeadlineProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_58: DefineComponent<LargeTitleProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<LargeTitleProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_59: DefineComponent<SubheadlineProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SubheadlineProps> & Readonly<{}>, {
level: SubheadlineLevel;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_6: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;

declare const __VLS_component_60: DefineComponent<TextProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TextProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_61: DefineComponent<TitleProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TitleProps> & Readonly<{}>, {
level: TitleLevel;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_62: DefineComponent<TypographyProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TypographyProps> & Readonly<{}>, {
weight: "1" | "2" | "3";
is: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_7: DefineComponent<ImageProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
load: (event: Event) => any;
error: (event: Event) => any;
}, string, PublicProps, Readonly<ImageProps> & Readonly<{
onLoad?: ((event: Event) => any) | undefined;
onError?: ((event: Event) => any) | undefined;
}>, {
size: 20 | 24 | 28 | 40 | 48 | 96;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_8: DefineComponent<ImageBadgeProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ImageBadgeProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_9: DefineComponent<ListProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ListProps> & Readonly<{}>, {
is: string | Component;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare function __VLS_template(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** Optional children to render within the image component's container. */
        default?: () => VNode[];
        /** An element (often an icon) displayed `acronym` props is not provided. */
        "fallback-icon"?: () => VNode[];
    }> & {
        /** Optional children to render within the image component's container. */
        default?: () => VNode[];
        /** An element (often an icon) displayed `acronym` props is not provided. */
        "fallback-icon"?: () => VNode[];
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_10(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** Element(s) to be displayed as the primary visual content, typically an image or an animation. */
        default?: () => VNode[];
        /** The primary text, usually a title or a header, for the placeholder. */
        header?: () => VNode[];
        /** Additional descriptive text to provide more details or context. */
        description?: () => VNode[];
        /** An actionable element, such as a button, to be placed in the placeholder for user interaction. */
        action?: () => VNode[];
    }> & {
        /** Element(s) to be displayed as the primary visual content, typically an image or an animation. */
        default?: () => VNode[];
        /** The primary text, usually a title or a header, for the placeholder. */
        header?: () => VNode[];
        /** Additional descriptive text to provide more details or context. */
        description?: () => VNode[];
        /** An actionable element, such as a button, to be placed in the placeholder for user interaction. */
        action?: () => VNode[];
    };
    refs: {};
    rootEl: HTMLElement;
};

declare function __VLS_template_11(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** The content for the section body. */
        default?: () => VNode[];
        /**
         * The content for the section header. If a string is passed, `SectionHeader` is automatically used.
         * For more control or a large title, use `<SectionHeader large>{{ headerText }}</SectionHeader>`.
         */
        header?: () => VNode[];
        /**
         * The content for the section footer. If a string is passed, `SectionFooter` is automatically used.
         * For a centered footer, use `<SectionFooter centered>{{ footerText }}</SectionFooter>`.
         */
        footer?: () => VNode[];
    }> & {
        /** The content for the section body. */
        default?: () => VNode[];
        /**
         * The content for the section header. If a string is passed, `SectionHeader` is automatically used.
         * For more control or a large title, use `<SectionHeader large>{{ headerText }}</SectionHeader>`.
         */
        header?: () => VNode[];
        /**
         * The content for the section footer. If a string is passed, `SectionFooter` is automatically used.
         * For a centered footer, use `<SectionFooter centered>{{ footerText }}</SectionFooter>`.
         */
        footer?: () => VNode[];
    };
    refs: {};
    rootEl: HTMLElement;
};

declare function __VLS_template_12(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
        default?(_: {}): any;
        default?(_: {}): any;
        default?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLElement;
};

declare function __VLS_template_13(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
        default?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLElement;
};

declare function __VLS_template_14(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** The default slot of the Timeline, expected to be a collection of `TimelineItem` components. */
        default?: () => VNode[];
    }> & {
        /** The default slot of the Timeline, expected to be a collection of `TimelineItem` components. */
        default?: () => VNode[];
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_15(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** Description of the item */
        default(props: unknown): unknown;
    }> & {
        /** Description of the item */
        default(props: unknown): unknown;
    };
    refs: {};
    rootEl: HTMLLIElement;
};

declare function __VLS_template_16(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** Inserts a component before the button text, typically an icon. */
        before?: () => VNode[];
        /** Inserts a component after the button text, such as a badge or indicator. */
        after?: () => VNode[];
        /** Main content of a button. */
        default?: () => VNode[];
    }> & {
        /** Inserts a component before the button text, typically an icon. */
        before?: () => VNode[];
        /** Inserts a component after the button text, such as a badge or indicator. */
        after?: () => VNode[];
        /** Main content of a button. */
        default?: () => VNode[];
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_17(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** Content displayed above the main content as a subheading */
        subhead?: () => VNode[];
        /** Main content displayed as a header */
        default?: () => VNode[];
        /** Content displayed alongside the header as a hint */
        hint?: () => VNode[];
        /** A badge component to be displayed next to the header */
        "title-badge"?: () => VNode[];
        /** Content displayed below the header as a subtitle */
        subtitle?: () => VNode[];
        /** Additional description displayed below the subtitle */
        description?: () => VNode[];
        /** Content or elements to be displayed on the left side of the cell */
        before?: () => VNode[];
        /** Content or elements to be displayed on the right side of the cell */
        after?: () => VNode[];
    }> & {
        /** Content displayed above the main content as a subheading */
        subhead?: () => VNode[];
        /** Main content displayed as a header */
        default?: () => VNode[];
        /** Content displayed alongside the header as a hint */
        hint?: () => VNode[];
        /** A badge component to be displayed next to the header */
        "title-badge"?: () => VNode[];
        /** Content displayed below the header as a subtitle */
        subtitle?: () => VNode[];
        /** Additional description displayed below the subtitle */
        description?: () => VNode[];
        /** Content or elements to be displayed on the left side of the cell */
        before?: () => VNode[];
        /** Content or elements to be displayed on the right side of the cell */
        after?: () => VNode[];
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_18(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** An `AvatarStack` component to display when the `type` is 'avatarStack', showcasing multiple avatars. */
        "avatar-stack"?: () => VNode[];
        /** Main content displayed as a header */
        default?: () => VNode[];
        /** Content displayed below the header as a subtitle */
        subtitle?: () => VNode[];
    }> & {
        /** An `AvatarStack` component to display when the `type` is 'avatarStack', showcasing multiple avatars. */
        "avatar-stack"?: () => VNode[];
        /** Main content displayed as a header */
        default?: () => VNode[];
        /** Content displayed below the header as a subtitle */
        subtitle?: () => VNode[];
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_19(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** Text content of the navigation component */
        default?: () => VNode[];
    }> & {
        /** Text content of the navigation component */
        default?: () => VNode[];
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_2(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_20(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** Element or component displayed before the main content, adding visual context or functionality. */
        before?: () => VNode[];
        /** Element or component displayed after the main content, typically indicating a possible action or outcome. */
        after?: () => VNode[];
        /** The content within the button cell, usually text. */
        default?: () => VNode[];
    }> & {
        /** Element or component displayed before the main content, adding visual context or functionality. */
        before?: () => VNode[];
        /** Element or component displayed after the main content, typically indicating a possible action or outcome. */
        after?: () => VNode[];
        /** The content within the button cell, usually text. */
        default?: () => VNode[];
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_21(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** Element(s) to be placed on the left side of the banner, typically an icon or an image. */
        before?: () => VNode[];
        /** Content displayed above the main content as a subheading */
        callout?: () => VNode[];
        /** The main text or title displayed in the banner. */
        header?: () => VNode[];
        /** Additional information or subtext displayed below the header. */
        subheader?: () => VNode[];
        /** Further details or description provided under the subheader. */
        description?: () => VNode[];
        /** Custom background component or design, such as an image or gradient, that covers the banner's area. */
        background?: () => VNode[];
        /** Content or components, such as buttons, displayed within the banner. */
        default?: () => VNode[];
    }> & {
        /** Element(s) to be placed on the left side of the banner, typically an icon or an image. */
        before?: () => VNode[];
        /** Content displayed above the main content as a subheading */
        callout?: () => VNode[];
        /** The main text or title displayed in the banner. */
        header?: () => VNode[];
        /** Additional information or subtext displayed below the header. */
        subheader?: () => VNode[];
        /** Further details or description provided under the subheader. */
        description?: () => VNode[];
        /** Custom background component or design, such as an image or gradient, that covers the banner's area. */
        background?: () => VNode[];
        /** Content or components, such as buttons, displayed within the banner. */
        default?: () => VNode[];
    };
    refs: {};
    rootEl: HTMLElement;
};

declare function __VLS_template_22(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLElement;
};

declare function __VLS_template_23(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** Content displayed above the main content as a subheading */
        subhead?: () => VNode[];
        /** Main content displayed as a header */
        default?: () => VNode[];
        /** Content displayed alongside the header as a hint */
        hint?: () => VNode[];
        /** A badge component to be displayed next to the header */
        "title-badge"?: () => VNode[];
        /** Content displayed below the header as a subtitle */
        subtitle?: () => VNode[];
        /** Additional description displayed below the subtitle */
        description?: () => VNode[];
        /** Content or elements to be displayed on the left side of the cell */
        before?: () => VNode[];
        /** Content or elements to be displayed on the right side of the cell */
        after?: () => VNode[];
    }> & {
        /** Content displayed above the main content as a subheading */
        subhead?: () => VNode[];
        /** Main content displayed as a header */
        default?: () => VNode[];
        /** Content displayed alongside the header as a hint */
        hint?: () => VNode[];
        /** A badge component to be displayed next to the header */
        "title-badge"?: () => VNode[];
        /** Content displayed below the header as a subtitle */
        subtitle?: () => VNode[];
        /** Additional description displayed below the subtitle */
        description?: () => VNode[];
        /** Content or elements to be displayed on the left side of the cell */
        before?: () => VNode[];
        /** Content or elements to be displayed on the right side of the cell */
        after?: () => VNode[];
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_24(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** Content or component to be placed before the main text, typically an icon or avatar. */
        before?: () => VNode[];
        /** Content or component to be placed after the main text, such as an icon indicating an action. */
        after?: () => VNode[];
        /** The main text content of the chip. */
        default?: () => VNode[];
    }> & {
        /** Content or component to be placed before the main text, typically an icon or avatar. */
        before?: () => VNode[];
        /** Content or component to be placed after the main text, such as an icon indicating an action. */
        after?: () => VNode[];
        /** The main text content of the chip. */
        default?: () => VNode[];
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_25(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_26(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /**
         * Content of the Accordion component. Pass `AccordionSummary` and
         * `AccordionContent` to create a functional accordion structure.
         */
        default?: () => VNode[];
    }> & {
        /**
         * Content of the Accordion component. Pass `AccordionSummary` and
         * `AccordionContent` to create a functional accordion structure.
         */
        default?: () => VNode[];
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_27(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {
        body: HTMLDivElement;
    };
    rootEl: HTMLDivElement;
};

declare function __VLS_template_28(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** Content displayed above the main content as a subheading */
        subhead?: () => VNode[];
        /** Main content displayed as a header */
        default?: () => VNode[];
        /** Content displayed alongside the header as a hint */
        hint?: () => VNode[];
        /** A badge component to be displayed next to the header */
        "title-badge"?: () => VNode[];
        /** Content displayed below the header as a subtitle */
        subtitle?: () => VNode[];
        /** Additional description displayed below the subtitle */
        description?: () => VNode[];
        /** Content or elements to be displayed on the left side of the cell */
        before?: () => VNode[];
        /** Content or elements to be displayed on the right side of the cell */
        after?: () => VNode[];
    }> & {
        /** Content displayed above the main content as a subheading */
        subhead?: () => VNode[];
        /** Main content displayed as a header */
        default?: () => VNode[];
        /** Content displayed alongside the header as a hint */
        hint?: () => VNode[];
        /** A badge component to be displayed next to the header */
        "title-badge"?: () => VNode[];
        /** Content displayed below the header as a subtitle */
        subtitle?: () => VNode[];
        /** Additional description displayed below the subtitle */
        description?: () => VNode[];
        /** Content or elements to be displayed on the left side of the cell */
        before?: () => VNode[];
        /** Content or elements to be displayed on the right side of the cell */
        after?: () => VNode[];
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_29(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** Typically an Icon, to be rendered inside the button. */
        default?: () => VNode[];
    }> & {
        /** Typically an Icon, to be rendered inside the button. */
        default?: () => VNode[];
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_3(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** An array of `Avatar` components to be rendered within the stack. */
        default?: () => VNode[];
    }> & {
        /** An array of `Avatar` components to be rendered within the stack. */
        default?: () => VNode[];
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_30(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /**
         * Should be a list of `InlineButtonsItem` components. Each child will inherit the `mode`
         * from this parent, ensuring consistent styling across all items.
         */
        default?: () => VNode[];
    }> & {
        /**
         * Should be a list of `InlineButtonsItem` components. Each child will inherit the `mode`
         * from this parent, ensuring consistent styling across all items.
         */
        default?: () => VNode[];
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_31(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_32(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_33(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_34(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** Content or component to be placed before the main text, typically an icon or avatar. */
        before?: () => VNode[];
        /** Content or component to be placed after the main text, such as an icon indicating an action. */
        after?: () => VNode[];
        /** The main text content of the chip. */
        default?: () => VNode[];
    }> & {
        /** Content or component to be placed before the main text, typically an icon or avatar. */
        before?: () => VNode[];
        /** Content or component to be placed after the main text, such as an icon indicating an action. */
        after?: () => VNode[];
        /** The main text content of the chip. */
        default?: () => VNode[];
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_35(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_36(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_37(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** The icon displayed on the tab. It should have dimensions of 28x28. */
        default?: () => VNode[];
        /** The text displayed on the tab. */
        text?: () => VNode[];
    }> & {
        /** The icon displayed on the tab. It should have dimensions of 28x28. */
        default?: () => VNode[];
        /** The text displayed on the tab. */
        text?: () => VNode[];
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_38(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** The child elements of the Tabbar, expected to be `TabbarItem` components. */
        default(): VNode[];
    }> & {
        /** The child elements of the Tabbar, expected to be `TabbarItem` components. */
        default(): VNode[];
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_39(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** Content of the breadcrumbs. */
        default?: () => VNode[];
    }> & {
        /** Content of the breadcrumbs. */
        default?: () => VNode[];
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_4(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** Text content of the badge. */
        default?: () => VNode[];
    }> & {
        /** Text content of the badge. */
        default?: () => VNode[];
    };
    refs: {};
    rootEl: HTMLSpanElement;
};

declare function __VLS_template_40(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_41(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_42(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** Content of the compact pagination item component.  */
        default?: () => VNode[];
    }> & {
        /** Content of the compact pagination item component.  */
        default?: () => VNode[];
    };
    refs: {};
    rootEl: HTMLButtonElement;
};

declare function __VLS_template_43(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLAnchorElement;
};

declare function __VLS_template_44(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_45(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** Children should be TabsListItem components to be rendered as tabs. */
        default?: () => VNode[];
    }> & {
        /** Children should be TabsListItem components to be rendered as tabs. */
        default?: () => VNode[];
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_46(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_47(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** Children should be SegmentedControlItem components to render within the control. */
        default?: () => VNode[];
    }> & {
        /** Children should be SegmentedControlItem components to render within the control. */
        default?: () => VNode[];
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_48(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_49(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        default?: () => VNode[];
        /** Inserts a component before the header text, e.g. Icon */
        before?: () => VNode[];
        /** Inserts a component after the header text, e.g. Icon */
        after?: () => VNode[];
    }> & {
        default?: () => VNode[];
        /** Inserts a component before the header text, e.g. Icon */
        before?: () => VNode[];
        /** Inserts a component after the header text, e.g. Icon */
        after?: () => VNode[];
    };
    refs: {};
    rootEl: HTMLElement;
};

declare function __VLS_template_5(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** The main content of the blockquote. When `type` is 'text', this content is wrapped in a typography component. */
        default?: () => VNode[];
        /** An optional icon displayed in the top right corner of the blockquote. Defaults to a quote icon. */
        "top-right-icon"?: () => VNode[];
    }> & {
        /** The main content of the blockquote. When `type` is 'text', this content is wrapped in a typography component. */
        default?: () => VNode[];
        /** An optional icon displayed in the top right corner of the blockquote. Defaults to a quote icon. */
        "top-right-icon"?: () => VNode[];
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_50(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_51(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_52(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_53(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {
        appRoot: HTMLDivElement;
    };
    rootEl: HTMLDivElement;
};

declare function __VLS_template_54(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_55(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_56(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_57(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_58(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_59(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_6(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_60(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_61(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_62(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_7(): {
    attrs: Partial<{}>;
    slots: Readonly<{
        /** Optional children to render within the image component's container. */
        default?: () => VNode[];
        /** An element (often an icon) displayed when the image fails to load or the `src` attribute is not provided. */
        "fallback-icon"?: () => VNode[];
    }> & {
        /** Optional children to render within the image component's container. */
        default?: () => VNode[];
        /** An element (often an icon) displayed when the image fails to load or the `src` attribute is not provided. */
        "fallback-icon"?: () => VNode[];
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_8(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_9(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;

declare type __VLS_TemplateResult_10 = ReturnType<typeof __VLS_template_10>;

declare type __VLS_TemplateResult_11 = ReturnType<typeof __VLS_template_11>;

declare type __VLS_TemplateResult_12 = ReturnType<typeof __VLS_template_12>;

declare type __VLS_TemplateResult_13 = ReturnType<typeof __VLS_template_13>;

declare type __VLS_TemplateResult_14 = ReturnType<typeof __VLS_template_14>;

declare type __VLS_TemplateResult_15 = ReturnType<typeof __VLS_template_15>;

declare type __VLS_TemplateResult_16 = ReturnType<typeof __VLS_template_16>;

declare type __VLS_TemplateResult_17 = ReturnType<typeof __VLS_template_17>;

declare type __VLS_TemplateResult_18 = ReturnType<typeof __VLS_template_18>;

declare type __VLS_TemplateResult_19 = ReturnType<typeof __VLS_template_19>;

declare type __VLS_TemplateResult_2 = ReturnType<typeof __VLS_template_2>;

declare type __VLS_TemplateResult_20 = ReturnType<typeof __VLS_template_20>;

declare type __VLS_TemplateResult_21 = ReturnType<typeof __VLS_template_21>;

declare type __VLS_TemplateResult_22 = ReturnType<typeof __VLS_template_22>;

declare type __VLS_TemplateResult_23 = ReturnType<typeof __VLS_template_23>;

declare type __VLS_TemplateResult_24 = ReturnType<typeof __VLS_template_24>;

declare type __VLS_TemplateResult_25 = ReturnType<typeof __VLS_template_25>;

declare type __VLS_TemplateResult_26 = ReturnType<typeof __VLS_template_26>;

declare type __VLS_TemplateResult_27 = ReturnType<typeof __VLS_template_27>;

declare type __VLS_TemplateResult_28 = ReturnType<typeof __VLS_template_28>;

declare type __VLS_TemplateResult_29 = ReturnType<typeof __VLS_template_29>;

declare type __VLS_TemplateResult_3 = ReturnType<typeof __VLS_template_3>;

declare type __VLS_TemplateResult_30 = ReturnType<typeof __VLS_template_30>;

declare type __VLS_TemplateResult_31 = ReturnType<typeof __VLS_template_31>;

declare type __VLS_TemplateResult_32 = ReturnType<typeof __VLS_template_32>;

declare type __VLS_TemplateResult_33 = ReturnType<typeof __VLS_template_33>;

declare type __VLS_TemplateResult_34 = ReturnType<typeof __VLS_template_34>;

declare type __VLS_TemplateResult_35 = ReturnType<typeof __VLS_template_35>;

declare type __VLS_TemplateResult_36 = ReturnType<typeof __VLS_template_36>;

declare type __VLS_TemplateResult_37 = ReturnType<typeof __VLS_template_37>;

declare type __VLS_TemplateResult_38 = ReturnType<typeof __VLS_template_38>;

declare type __VLS_TemplateResult_39 = ReturnType<typeof __VLS_template_39>;

declare type __VLS_TemplateResult_4 = ReturnType<typeof __VLS_template_4>;

declare type __VLS_TemplateResult_40 = ReturnType<typeof __VLS_template_40>;

declare type __VLS_TemplateResult_41 = ReturnType<typeof __VLS_template_41>;

declare type __VLS_TemplateResult_42 = ReturnType<typeof __VLS_template_42>;

declare type __VLS_TemplateResult_43 = ReturnType<typeof __VLS_template_43>;

declare type __VLS_TemplateResult_44 = ReturnType<typeof __VLS_template_44>;

declare type __VLS_TemplateResult_45 = ReturnType<typeof __VLS_template_45>;

declare type __VLS_TemplateResult_46 = ReturnType<typeof __VLS_template_46>;

declare type __VLS_TemplateResult_47 = ReturnType<typeof __VLS_template_47>;

declare type __VLS_TemplateResult_48 = ReturnType<typeof __VLS_template_48>;

declare type __VLS_TemplateResult_49 = ReturnType<typeof __VLS_template_49>;

declare type __VLS_TemplateResult_5 = ReturnType<typeof __VLS_template_5>;

declare type __VLS_TemplateResult_50 = ReturnType<typeof __VLS_template_50>;

declare type __VLS_TemplateResult_51 = ReturnType<typeof __VLS_template_51>;

declare type __VLS_TemplateResult_52 = ReturnType<typeof __VLS_template_52>;

declare type __VLS_TemplateResult_53 = ReturnType<typeof __VLS_template_53>;

declare type __VLS_TemplateResult_54 = ReturnType<typeof __VLS_template_54>;

declare type __VLS_TemplateResult_55 = ReturnType<typeof __VLS_template_55>;

declare type __VLS_TemplateResult_56 = ReturnType<typeof __VLS_template_56>;

declare type __VLS_TemplateResult_57 = ReturnType<typeof __VLS_template_57>;

declare type __VLS_TemplateResult_58 = ReturnType<typeof __VLS_template_58>;

declare type __VLS_TemplateResult_59 = ReturnType<typeof __VLS_template_59>;

declare type __VLS_TemplateResult_6 = ReturnType<typeof __VLS_template_6>;

declare type __VLS_TemplateResult_60 = ReturnType<typeof __VLS_template_60>;

declare type __VLS_TemplateResult_61 = ReturnType<typeof __VLS_template_61>;

declare type __VLS_TemplateResult_62 = ReturnType<typeof __VLS_template_62>;

declare type __VLS_TemplateResult_7 = ReturnType<typeof __VLS_template_7>;

declare type __VLS_TemplateResult_8 = ReturnType<typeof __VLS_template_8>;

declare type __VLS_TemplateResult_9 = ReturnType<typeof __VLS_template_9>;

declare type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_10<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_11<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_12<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_13<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_14<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_15<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_16<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_17<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_18<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_19<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_2<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_20<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_21<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_22<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_23<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_24<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_25<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_26<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_27<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_28<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_29<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_3<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_30<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_31<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_32<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_33<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_34<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_35<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_36<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_37<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_38<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_39<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_4<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_40<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_41<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_42<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_43<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_44<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_45<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_46<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_47<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_48<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_49<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_5<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_50<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_51<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_52<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_53<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_54<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_55<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_56<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_57<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_58<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_59<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_6<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_60<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_61<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_62<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_63<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_64<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_65<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_66<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_67<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_68<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_69<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_7<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_70<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_71<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_72<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_8<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_9<T, S> = T & {
    new (): {
        $slots: S;
    };
};

export declare const Accordion: __VLS_WithTemplateSlots_26<typeof __VLS_component_26, __VLS_TemplateResult_26["slots"]>;

export declare const AccordionContent: __VLS_WithTemplateSlots_27<typeof __VLS_component_27, __VLS_TemplateResult_27["slots"]>;

export declare interface AccordionProps {
    /**
     * Optional ID for the accordion element, enhancing accessibility (a11y) by associating the accordion
     * summary and content. If not provided, a unique ID will be generated automatically.
     * This ID is crucial for screen readers and other assistive technologies to understand the
     * relationship between the accordion header and content.
     */
    id?: string;
    /** Determines whether the accordion is currently expanded or collapsed. */
    expanded?: boolean;
}

export declare const AccordionSummary: __VLS_WithTemplateSlots_28<typeof __VLS_component_28, __VLS_TemplateResult_28["slots"]>;

/**
 * `AccordionSummary` serves as the clickable header for an accordion section, toggling the visibility of the content.
 * It incorporates an expand/collapse icon to visually indicate state. This component further extends `Cell` to provide
 * a consistent UI and accessibility features.
 */
export declare interface AccordionSummaryProps extends /* @vue-ignore */ CellProps {
}

export declare const AppRoot: __VLS_WithTemplateSlots_63<typeof __VLS_component_53, __VLS_TemplateResult_53["slots"]>;

declare interface AppRootInjection {
    platform: 'base' | 'ios';
    appearance?: 'light' | 'dark';
    teleportContainer?: HTMLDivElement;
    isRendered: boolean;
}

declare interface AppRootProps {
    /** Application platform, determined automatically if nothing passed */
    platform?: AppRootInjection['platform'];
    /** Application appearance, determined automatically if nothing passed */
    appearance?: AppRootInjection['appearance'];
    /** Rewriting teleport container for rendering, AppRoot container as default */
    teleportContainer?: AppRootInjection['teleportContainer'];
}

/**
 * Renders an image with specific styles for an avatar presentation, including optional acronym display and badge support.
 * Utilizes the `Image` component for core functionality, enhancing it with avatar-specific features like acronyms and badges.
 */
declare interface Attrs extends ImageProps, ImgHTMLAttributes {
}

/**
 * `Cell` component acts as a flexible and interactive container for various types of content,
 * enabling the creation of complex list items, form fields, and more. It leverages the `Tappable`
 * component for interaction and is designed to be flexible and extensible.
 */
declare type Attrs_2 = Omit<TappableProps, 'is'>;

/**
 * Renders an interactive cell component with optional leading and trailing elements. Designed to be flexible,
 * supporting various content structures and interaction models within UI designs.
 */
declare type Attrs_3 = Omit<TappableProps, 'is'>;

/**
 * Wraps an input element with additional layout for headers, icons, or actions, providing a consistent look and feel across the form.
 * It supports conditional rendering based on the platform and the state of the form element.
 */
declare interface Attrs_4 extends InputHTMLAttributes, LabelHTMLAttributes {
}

/**
 * Renders a custom styled select input within a `FormInput` container. This component is designed to integrate seamlessly
 * with the form input styles, providing a consistent look and enhanced features such as a custom dropdown arrow and support
 * for platform-specific typography. The `FormInput` wrapper facilitates the inclusion of headers and status messages.
 */
declare interface Attrs_5 extends FormInputProps, SelectHTMLAttributes {
}

/**
 * Wraps a standard HTML textarea element within a `FormInput` container, applying custom styles and functionality.
 * This component inherits the flexible design of the `FormInput`, allowing it to display a header and reflect different status styles.
 * The appearance and behavior of the textarea can be customized through various props, providing a seamless integration with forms.
 */
declare interface Attrs_6 extends Omit<FormInputProps, 'value'>, TextareaHTMLAttributes {
}

/**
 * The Pagination component displays a set of navigation controls allowing users to navigate through pages of content.
 * It is built on top of a custom hook that manages pagination logic and state.
 * This component can be customized to hide next/previous buttons, specify boundary and sibling count for pagination items, and handle page changes through an `change` event.
 */
declare interface Attrs_7 extends UnwrapRef<Omit<UsePaginationConfig, 'onChange'>> {
}

/**
 * Renders a Popper component, leveraging floating UI for dynamic, responsive positioning.
 * Supports advanced configurations like virtual elements, custom arrows, and auto-position updates.
 */
declare interface Attrs_8 extends Omit<UseFloatingMiddlewaresConfig, 'arrowHeight' | 'arrowPadding' | 'arrowRef'> {
}

declare type AutoPlacement = 'auto' | 'auto-start' | 'auto-end';

export declare const Avatar: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

export declare const AvatarBadge: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;

export declare interface AvatarBadgeProps extends /* @vue-ignore */ BadgeProps {
}

export declare interface AvatarProps extends /* @vue-ignore */ Attrs {
    /** One or two letters to be shown as a placeholder. `fallback-icon` will not be used if `acronym` is provided. */
    acronym?: string;
}

export declare const AvatarStack: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, __VLS_TemplateResult_3["slots"]>;

export declare const Badge: __VLS_WithTemplateSlots_4<typeof __VLS_component_4, __VLS_TemplateResult_4["slots"]>;

/**
 * The `Badge` component renders a small numeric or dot indicator, typically used for notifications, statuses, or counts.
 * It supports several visual modes for different contexts (e.g., critical, primary) and can be sized normally or enlarged.
 */
export declare interface BadgeProps {
    /** The visual style of the badge: 'number' displays the content, 'dot' shows a simple dot. */
    type: 'number' | 'dot';
    /** The color scheme of the badge, affecting its background and text color. */
    mode?: 'primary' | 'critical' | 'secondary' | 'gray' | 'white';
    /** Increases the size of the badge. Applicable only when `type` is 'number'. */
    large?: boolean;
}

export declare const Banner: __VLS_WithTemplateSlots_21<typeof __VLS_component_21, __VLS_TemplateResult_21["slots"]>;

/**
 * The `Banner` component renders a prominent graphical element, typically displayed at the top of a page or section,
 * designed to grab the user's attention and convey important information.
 * It is a versatile tool used for various purposes such as branding, promotion, announcements, or navigation.
 */
export declare interface BannerProps {
    /** Specifies the banner's layout style, which can affect its positioning and styling. */
    type?: 'section' | 'inline';
    /** Specifies whether to show the close icon or not. */
    showCloseIcon?: boolean;
}

export declare const Blockquote: __VLS_WithTemplateSlots_5<typeof __VLS_component_5, __VLS_TemplateResult_5["slots"]>;

/**
 * Renders a stylized blockquote element, typically used for quotations or special text. The component can include an
 * icon in the top right corner and supports different content types for flexible use within UI designs.
 */
export declare interface BlockquoteProps {
    /** Determines the content type within the blockquote, influencing its presentation. */
    type?: 'text' | 'other';
}

export declare const Breadcrumbs: __VLS_WithTemplateSlots_47<typeof __VLS_component_39, __VLS_TemplateResult_39["slots"]>;

export declare const BreadcrumbsItem: __VLS_WithTemplateSlots_48<typeof __VLS_component_40, __VLS_TemplateResult_40["slots"]>;

export declare interface BreadcrumbsItemProps {
    is?: string;
}

export declare interface BreadcrumbsProps {
    /** Type of divider to use between breadcrumb items. */
    divider?: 'dot' | 'slash' | 'chevron';
}

export declare const Button: __VLS_WithTemplateSlots_16<typeof __VLS_component_16, __VLS_TemplateResult_16["slots"]>;

export declare const ButtonCell: __VLS_WithTemplateSlots_20<typeof __VLS_component_20, __VLS_TemplateResult_20["slots"]>;

export declare interface ButtonCellProps extends /* @vue-ignore */ Attrs_3 {
    /** Determines the button cell's visual theme, influencing color and style. */
    mode?: 'default' | 'destructive';
    /** Specifies the root element type for more semantic HTML structure or integration with navigation libraries. */
    is?: Component | string;
}

export declare interface ButtonProps extends /* @vue-ignore */ Omit<ButtonHTMLAttributes, 'is'> {
    /** Controls the size of the button, influencing padding and font size. */
    size?: 's' | 'm' | 'l';
    /** If true, stretches the button to fill the width with its container. */
    stretched?: boolean;
    /** Defines the button's visual style, affecting its background and text color. */
    mode?: 'filled' | 'bezeled' | 'plain' | 'gray' | 'outline' | 'white';
    /** Displays a loading indicator in place of the button content when true. */
    loading?: boolean;
    /** Disables the button, preventing user interactions, when true. */
    disabled?: boolean;
    /** Specifies the root element type for the button, allowing for semantic customization or integration with routing libraries. */
    is?: Component | string;
}

export declare const Caption: __VLS_WithTemplateSlots_66<typeof __VLS_component_56, __VLS_TemplateResult_56["slots"]>;

/**
 * The Caption component is a text wrapper that applies specific typographic styles,
 * based on the provided `level` prop. It's built on top of the Typography component,
 * ensuring consistent text styling across the application. It primarily serves for text
 * that acts as a small, descriptive label or annotation.
 */
declare type CaptionLevel = '1' | '2';

export declare interface CaptionProps extends /* @vue-ignore */ Omit<TypographyProps, 'plain'> {
    /** The size level of the caption, influencing its styling and typography size. */
    level?: CaptionLevel;
}

export declare const Card: __VLS_WithTemplateSlots_22<typeof __VLS_component_22, __VLS_TemplateResult_22["slots"]>;

export declare const CardCell: __VLS_WithTemplateSlots_23<typeof __VLS_component_23, __VLS_TemplateResult_23["slots"]>;

export declare interface CardCellProps extends /* @vue-ignore */ CellProps {
}

export declare const CardChip: __VLS_WithTemplateSlots_24<typeof __VLS_component_24, __VLS_TemplateResult_24["slots"]>;

export declare interface CardChipProps extends /* @vue-ignore */ ChipProps {
}

declare interface CardInjection {
    type: 'plain' | 'ambient';
}

/**
 * Serves as a container for card-styled UI elements, providing context for its child components.
 * It supports different visual styles and can encapsulate various content types.
 */
export declare interface CardProps {
    /** Defines the visual style of the card, influencing background, shadow, and border. */
    type?: CardInjection['type'];
}

export declare const Cell: __VLS_WithTemplateSlots_17<typeof __VLS_component_17, __VLS_TemplateResult_17["slots"]>;

export declare interface CellProps extends /* @vue-ignore */ Attrs_2 {
    /** Controls the hover state of the component externally, useful for keyboard navigation */
    hovered?: boolean;
    /** Allows for multiline content without truncation */
    multiline?: boolean;
    /** Custom component or HTML tag to be used as the root element of the cell, div by default */
    is?: Component | string;
}

export declare const Checkbox: DefineComponent<CheckboxProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<CheckboxProps> & Readonly<{}>, {
indeterminate: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
checkbox: ({
$: ComponentInternalInstance;
$data: {};
$props: {
readonly is?: string | undefined;
} & VNodeProps & AllowedComponentProps & ComponentCustomProps & Readonly<VisuallyHiddenProps_2> & Readonly<{}>;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: Slot<any> | undefined;
}>;
$root: ComponentPublicInstance | null;
$parent: ComponentPublicInstance | null;
$host: Element | null;
$emit: (event: string, ...args: any[]) => void;
$el: any;
$options: ComponentOptionsBase<Readonly<VisuallyHiddenProps_2> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
is: string;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
beforeCreate?: (() => void) | (() => void)[];
created?: (() => void) | (() => void)[];
beforeMount?: (() => void) | (() => void)[];
mounted?: (() => void) | (() => void)[];
beforeUpdate?: (() => void) | (() => void)[];
updated?: (() => void) | (() => void)[];
activated?: (() => void) | (() => void)[];
deactivated?: (() => void) | (() => void)[];
beforeDestroy?: (() => void) | (() => void)[];
beforeUnmount?: (() => void) | (() => void)[];
destroyed?: (() => void) | (() => void)[];
unmounted?: (() => void) | (() => void)[];
renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
};
$forceUpdate: () => void;
$nextTick: nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
} & Readonly<{
is: string;
}> & Omit<Readonly<VisuallyHiddenProps_2> & Readonly<{}>, "is"> & ShallowUnwrapRef<    {}> & {} & ComponentCustomProperties & {} & {
$slots: {
default?(_: {}): any;
};
}) | null;
}, any>;

/**
 * Renders a checkbox input with custom styling and optional indeterminate state.
 * The component visually hides the actual input element for accessibility while providing a custom styled appearance.
 */
export declare interface CheckboxProps extends /* @vue-ignore */ InputHTMLAttributes {
    /** If true, displays the checkbox with an indeterminate icon instead of checked or unchecked. */
    indeterminate?: boolean;
}

export declare const Chip: __VLS_WithTemplateSlots_39<typeof __VLS_component_34, __VLS_TemplateResult_34["slots"]>;

export declare interface ChipProps {
    /** Defines the visual style of the chip, affecting its background, border, and shadow. */
    mode?: 'elevated' | 'mono' | 'outline';
    /** Specifies the HTML tag or component used to render the Chip, defaulting to `div`. */
    is?: Component | string;
}

export declare const CircularProgress: DefineComponent<CircularProgressProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<CircularProgressProps> & Readonly<{}>, {
size: "small" | "medium" | "large";
progress: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, SVGSVGElement>;

/**
 * Renders a circular progress indicator, useful for displaying loading states or progress metrics.
 * The component dynamically adjusts its size and stroke based on the provided `size` prop and visually represents
 * the `progress` prop as a percentage of the circle's circumference.
 */
export declare interface CircularProgressProps {
    /** Specifies the size of the circular progress indicator. Can be 'small', 'medium', or 'large'. */
    size?: 'small' | 'medium' | 'large';
    /** Current progress of the circular indicator, expressed as a percentage from 0 to 100. */
    progress?: number;
}

export declare const ColorInput: __VLS_WithTemplateSlots_40<DefineComponent<ColorInputProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ColorInputProps> & Readonly<{}>, {
value: any;
status: "default" | "error" | "focused";
defaultValue: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, Readonly<{
    /** Optional header content, displayed above the form input on `base` platform. */
    header?: () => VNode[];
    /** Content to be displayed before the form input, such as icons or labels. */
    before?: () => VNode[];
}> & {
    /** Optional header content, displayed above the form input on `base` platform. */
    header?: () => VNode[];
    /** Content to be displayed before the form input, such as icons or labels. */
    before?: () => VNode[];
}>;

/**
 * Renders a color picker input within a form structure, displaying the selected color value.
 * It adapts the text style based on the platform and supports additional properties like header and status.
 */
export declare interface ColorInputProps extends /* @vue-ignore */ FormInputProps {
    defaultValue?: string;
}

export declare const CompactPagination: __VLS_WithTemplateSlots_49<typeof __VLS_component_41, __VLS_TemplateResult_41["slots"]>;

export declare const CompactPaginationItem: __VLS_WithTemplateSlots_50<typeof __VLS_component_42, __VLS_TemplateResult_42["slots"]>;

export declare interface CompactPaginationItemProps extends /* @vue-ignore */ ButtonHTMLAttributes {
    selected?: boolean;
}

/**
 * Displays a compact set of pagination controls. This component allows users to navigate
 * between pages of content. It supports several themes for customization and can fit within various UI designs.
 */
export declare interface CompactPaginationProps {
    /** Sets the color theme of the pagination. */
    mode?: 'default' | 'ambient' | 'white';
}

export declare const Divider: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLHRElement>;

export declare const FileInput: __VLS_WithTemplateSlots_41<typeof __VLS_component_35, __VLS_TemplateResult_35["slots"]>;

/**
 * Renders a file input disguised as a button, enhancing the user interface and improving usability.
 * It leverages the `ButtonCell` component for consistent styling across the application.
 */
export declare interface FileInputProps extends /* @vue-ignore */ InputHTMLAttributes {
    /** Text label for the file input, used as the button label. */
    label?: string;
}

export declare const FixedLayout: __VLS_WithTemplateSlots_44<typeof __VLS_component_36, __VLS_TemplateResult_36["slots"]>;

/**
 * This component provides a flexible way to create a layout that is fixed to either the top or bottom of its parent container.
 * It's useful for creating headers, footers, or any element that should remain in view regardless of the scrolling content.
 */
export declare interface FixedLayoutProps {
    /** The component type to render, allowing for semantic HTML use. Defaults to 'div'. */
    is?: Component | string;
    /** Determines the vertical positioning of the layout within its container. Options are 'top' or 'bottom'. */
    vertical?: 'top' | 'bottom';
}

declare interface FormInputProps extends /* @vue-ignore */ Attrs_4 {
    /** Defines the visual state of the form input (e.g., error, focused). */
    status?: 'default' | 'error' | 'focused';
}

export declare const Headline: __VLS_WithTemplateSlots_67<typeof __VLS_component_57, __VLS_TemplateResult_57["slots"]>;

/**
 * The Headline component serves as a wrapper for text that is intended to be displayed prominently,
 * typically used for section headings or important titles within the application. It leverages the Typography
 * component for consistent typographic styling, offering a range of customization options through its props.
 * The component defaults to an `<h5>` HTML tag, providing semantic meaning and ensuring good SEO practices,
 * but can be customized as needed.
 */
export declare interface HeadlineProps extends /* @vue-ignore */ TypographyProps {
}

export declare const HorizontalScroll: __VLS_WithTemplateSlots_61<typeof __VLS_component_51, __VLS_TemplateResult_51["slots"]>;

export declare interface HorizontalScrollProps {
    is?: Component | string | number;
}

export declare const IconButton: __VLS_WithTemplateSlots_25<typeof __VLS_component_25, __VLS_TemplateResult_25["slots"]>;

/**
 * Renders an icon button with customizable size and mode. It utilizes the `Tappable` component for enhanced
 * touch interaction, allowing it to serve various UI actions efficiently.
 */
export declare interface IconButtonProps extends /* @vue-ignore */ ButtonHTMLAttributes {
    /** Specifies the button size, affecting icon scaling. Recommended icon sizes are 20px for 's', 24px for 'm', and 28px for 'l'. */
    size?: 's' | 'm' | 'l';
    /** Defines the button's visual style, affecting its color and background. */
    mode?: 'bezeled' | 'plain' | 'gray' | 'outline';
}

export declare const IconContainer: __VLS_WithTemplateSlots_6<typeof __VLS_component_6, __VLS_TemplateResult_6["slots"]>;

declare const Image_2: __VLS_WithTemplateSlots_7<typeof __VLS_component_7, __VLS_TemplateResult_7["slots"]>;
export { Image_2 as Image }

export declare const ImageBadge: __VLS_WithTemplateSlots_8<typeof __VLS_component_8, __VLS_TemplateResult_8["slots"]>;

export declare interface ImageBadgeProps extends /* @vue-ignore */ BadgeProps {
}

/**
 * Renders an image with optional fallback content. It supports custom sizing and will automatically
 * handle loading states and errors by optionally displaying a fallback icon. This component can also
 * include additional content, such as badges or overlays, as children.
 */
export declare interface ImageProps extends /* @vue-ignore */ ImgHTMLAttributes {
    /** Specifies the size of the image, with a default of 40. Sizes are defined in pixels. */
    size?: 20 | 24 | 28 | 40 | 48 | 96;
}

export declare const Info: __VLS_WithTemplateSlots_18<typeof __VLS_component_18, __VLS_TemplateResult_18["slots"]>;

/**
 * A versatile component designed to display either text information with an optional subtitle or a stack of avatars.
 * It adapts its structure based on the `type` prop, allowing for a wide range of use cases within user interfaces.
 */
export declare interface InfoProps {
    /** Determines the type of content to display, affecting the layout and styling. */
    type: 'text' | 'avatarStack';
    /** Text content for the component, utilized when the `type` is set to 'text'. */
    subtitle?: string;
}

export declare const InlineButtons: __VLS_WithTemplateSlots_30<typeof __VLS_component_30, __VLS_TemplateResult_30["slots"]>;

declare interface InlineButtonsInjection {
    mode?: 'plain' | 'bezeled' | 'gray';
}

export declare const InlineButtonsItem: __VLS_WithTemplateSlots_29<typeof __VLS_component_29, __VLS_TemplateResult_29["slots"]>;

/**
 * `InlineButtonsItem` is designed for use within an InlineButtons container but can also serve as a standalone button
 * if used by itself. It supports displaying optional text and can inherit a styling mode from its parent InlineButtons
 * context or utilize a locally defined mode. This flexibility allows it to seamlessly integrate within various layouts
 * and designs, providing a consistent and adaptable interface element.
 */
export declare interface InlineButtonsItemProps extends /* @vue-ignore */ ButtonHTMLAttributes {
    /** Optional mode for styling the button, with 'plain' as the default. */
    mode?: InlineButtonsInjection['mode'];
    /** Text displayed inside the button. */
    text?: string;
}

/**
 * `InlineButtons` acts as a container for `InlineButtonsItem` components. This component
 * provides a unified context for styling and interaction, leveraging the `mode` to apply
 * consistent styling across all child components. It ensures visual consistency across different
 * platforms and supports custom styling modes.
 */
export declare interface InlineButtonsProps {
    /** Dictates the styling mode for the inline buttons, affecting color and background. */
    mode?: InlineButtonsInjection['mode'];
}

export declare const Input: __VLS_WithTemplateSlots_35<DefineComponent<InputProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<InputProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    header?(_: {}): any;
    before?(_: {}): any;
    after?(_: {}): any;
}>;

/**
 * Renders a text input field with enhanced styling and integration into a form structure. Supports customization through props and standard input attributes.
 * It automatically adapts typography and layout based on the platform, ensuring a consistent user experience across devices.
 */
export declare interface InputProps extends /* @vue-ignore */ FormInputProps {
}

export declare const LargeTitle: __VLS_WithTemplateSlots_68<typeof __VLS_component_58, __VLS_TemplateResult_58["slots"]>;

/**
 * The LargeTitle component is designed for prominent display text, typically used for major headings
 * or titles within an application. It encapsulates the Typography component's features, offering
 * extensive styling and semantic customization options while defaulting to an `<h1>` HTML element.
 * This choice of default component underscores the importance and hierarchy of the text it encapsulates,
 * making it suitable for primary page titles or significant headings.
 */
export declare interface LargeTitleProps extends /* @vue-ignore */ TypographyProps {
}

export declare const Link: __VLS_WithTemplateSlots_51<typeof __VLS_component_43, __VLS_TemplateResult_43["slots"]>;

declare interface LinkProps extends /* @vue-ignore */ AnchorHTMLAttributes {
}

export declare const List: __VLS_WithTemplateSlots_9<typeof __VLS_component_9, __VLS_TemplateResult_9["slots"]>;

/**
 * Renders a container for list items, applying platform-specific styles for consistency across different operating systems.
 * This component serves as a foundational element for creating lists in a user interface.
 */
export declare interface ListProps {
    /** Specifies the HTML tag or component used to render the list, defaulting to `div`. */
    is?: string | Component;
}

export declare const Modal: __VLS_WithTemplateSlots_58<DefineComponent<ModalProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"update:open": (open: boolean) => any;
}, string, PublicProps, Readonly<ModalProps> & Readonly<{
"onUpdate:open"?: ((open: boolean) => any) | undefined;
}>, {
fixed: boolean;
open: boolean;
activeSnapPoint: number | string | null;
closeThreshold: number;
shouldScaleBackground: boolean;
setBackgroundColorOnScale: boolean;
scrollLockTimeout: number;
dismissible: boolean;
modal: boolean;
defaultOpen: boolean;
nested: boolean;
direction: DrawerDirection;
handleOnly: boolean;
snapPoints: (number | string)[];
fadeFromIndex: never;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, Readonly<{
    /** Modal content. */
    default?: () => VNode[];
    /** Custom header component to display at the top of the modal. */
    header?: () => VNode[];
    /** Custom component for the modal's overlay backdrop. */
    overlay?: () => VNode[];
    /** Component or element used to trigger the modal's visibility. */
    trigger?: () => VNode[];
}> & {
    /** Modal content. */
    default?: () => VNode[];
    /** Custom header component to display at the top of the modal. */
    header?: () => VNode[];
    /** Custom component for the modal's overlay backdrop. */
    overlay?: () => VNode[];
    /** Component or element used to trigger the modal's visibility. */
    trigger?: () => VNode[];
}>;

export declare const ModalClose: __VLS_WithTemplateSlots_56<typeof __VLS_component_48, __VLS_TemplateResult_48["slots"]>;

export declare const ModalHeader: __VLS_WithTemplateSlots_57<typeof __VLS_component_49, __VLS_TemplateResult_49["slots"]>;

export declare interface ModalProps {
    activeSnapPoint?: number | string | null;
    /**
     * Number between 0 and 1 that determines when the drawer should be closed.
     * Example: threshold of 0.5 would close the drawer if the user swiped for 50% of the height of the drawer or more.
     * @default 0.25
     */
    closeThreshold?: number;
    shouldScaleBackground?: boolean;
    /**
     * When `false` we don't change body's background color when the drawer is open.
     * @default true
     */
    setBackgroundColorOnScale?: boolean;
    /**
     * Duration for which the drawer is not draggable after scrolling content inside of the drawer.
     * @default 500ms
     */
    scrollLockTimeout?: number;
    /**
     * When `true`, don't move the drawer upwards if there's space, but rather only change it's height so it's fully scrollable when the keyboard is open
     */
    fixed?: boolean;
    /**
     * When `false` dragging, clicking outside, pressing esc, etc. will not close the drawer.
     * Use this in combination with the `open` prop, otherwise you won't be able to open/close the drawer.
     * @default true
     */
    dismissible?: boolean;
    /**
     * When `false` it allows to interact with elements outside of the drawer without closing it.
     * @default true
     */
    modal?: boolean;
    open?: boolean;
    /**
     * Opened by default, skips initial enter animation. Still reacts to `open` state changes
     * @default false
     */
    defaultOpen?: boolean;
    nested?: boolean;
    /**
     * Direction of the drawer. Can be `top` or `bottom`, `left`, `right`.
     * @default 'bottom'
     */
    direction?: DrawerDirection;
    /**
     * When `true` the `body` doesn't get any styles assigned from Vaul
     */
    noBodyStyles?: boolean;
    /**
     * When `true` only allows the drawer to be dragged by the `<Drawer.Handle />` component.
     * @default false
     */
    handleOnly?: boolean;
    preventScrollRestoration?: boolean;
    /**
     * Array of numbers from 0 to 100 that corresponds to % of the screen a given snap point should take up.
     * Should go from least visible. Example `[0.2, 0.5, 0.8]`.
     * You can also use px values, which doesn't take screen height into account.
     */
    snapPoints?: (number | string)[];
    /**
     * Index of a `snapPoint` from which the overlay fade should be applied. Defaults to the last snap point.
     */
    fadeFromIndex?: never;
}

export declare const Multiselectable: __VLS_WithTemplateSlots_43<DefineComponent<MultiselectableProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<MultiselectableProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

/**
 * Renders a custom multiselectable checkbox input, adapting its icons based on the current platform (iOS or others).
 * Supports all standard input checkbox properties.
 */
export declare interface MultiselectableProps extends /* @vue-ignore */ InputHTMLAttributes {
}

export declare const Navigation: __VLS_WithTemplateSlots_19<typeof __VLS_component_19, __VLS_TemplateResult_19["slots"]>;

declare type OnChange = (event: Event, page: number) => void;

export declare const Pagination: DefineComponent<PaginationProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
change: (event: Event, page: number) => any;
}, string, PublicProps, Readonly<PaginationProps> & Readonly<{
onChange?: ((event: Event, page: number) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare interface PaginationProps extends /* @vue-ignore */ Attrs_7 {
    /** Controls whether the Pagination component is interactive. */
    disabled?: boolean;
}

export declare const PinInput: DefineComponent<PinInputProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
change: (value: number[]) => any;
}, string, PublicProps, Readonly<PinInputProps> & Readonly<{
onChange?: ((value: number[]) => any) | undefined;
}>, {
label: string;
value: number[];
pinCount: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
pinInput: HTMLElement;
}, any>;

/**
 * Renders a set of input fields for entering pin codes with a virtual keypad for value entry and deletion.
 */
export declare interface PinInputProps extends /* @vue-ignore */ InputHTMLAttributes {
    /** Text label displayed above the pin input cells. */
    label?: string;
    /** The number of pin input fields to display, with a minimum of 2. */
    pinCount?: number;
    /** The initial pin values to populate the input fields with. */
    value?: number[];
}

export declare const Placeholder: __VLS_WithTemplateSlots_10<typeof __VLS_component_10, __VLS_TemplateResult_10["slots"]>;

declare type PlacementWithAuto = Placement | AutoPlacement;

export declare const Popper: __VLS_WithTemplateSlots_59<DefineComponent<PopperProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PopperProps> & Readonly<{}>, {
is: string | Component;
autoUpdateOnTargetResize: boolean;
arrowIcon: Component;
arrowProps: {
/** Optional distance from the target element, influencing the arrow's placement. */
offset?: number;
/** When true, the offset distance remains constant, regardless of the arrow's placement. */
isStaticOffset?: boolean;
/** Coordinates for the arrow, useful for precise positioning when the arrow is not directly adjacent to its target. */
coords?: Coords;
/** The preferred placement of the arrow relative to its target element. */
placement?: Placement;
/** A component for rendering the arrow icon, allowing for custom arrow designs. */
icon?: Component;
/** Optionally override the default arrow height. */
height?: number;
/** Optionally override the default arrow padding. */
padding?: number;
classes?: string[];
};
}, {}, {}, {}, string, ComponentProvideOptions, false, {
floating: unknown;
arrow: CreateComponentPublicInstanceWithMixins<Readonly<FloatingArrowProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, VNodeProps & AllowedComponentProps & ComponentCustomProps & Readonly<FloatingArrowProps> & Readonly<{}>, {
icon: Component;
placement: Placement;
offset: number;
coords: Partial<Coords>;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLDivElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<FloatingArrowProps> & Readonly<{}>, {}, {}, {}, {}, {
icon: Component;
placement: Placement;
offset: number;
coords: Partial<Coords>;
}> | null;
}, any>, {
    default?(_: {}): any;
}>;

export declare interface PopperProps extends /* @vue-ignore */ Attrs_8 {
    /** Reference to the anchor element for precise positioning. */
    anchor: MaybeElement<ReferenceElement>;
    /** Opt-in feature to automatically update Popper's position when the target element resizes. */
    autoUpdateOnTargetResize?: boolean;
    /** Defines the root element type of the Popper, allowing for semantic customization. */
    is?: string | Component;
    /** Optional custom component for the arrow icon, replacing the default. */
    arrowIcon?: Component;
    /** Configuration and customization options for the floating arrow component. */
    arrowProps?: {
        /** Optional distance from the target element, influencing the arrow's placement. */
        offset?: number;
        /** When true, the offset distance remains constant, regardless of the arrow's placement. */
        isStaticOffset?: boolean;
        /** Coordinates for the arrow, useful for precise positioning when the arrow is not directly adjacent to its target. */
        coords?: Coords;
        /** The preferred placement of the arrow relative to its target element. */
        placement?: Placement;
        /** A component for rendering the arrow icon, allowing for custom arrow designs. */
        icon?: Component;
        /** Optionally override the default arrow height. */
        height?: number;
        /** Optionally override the default arrow padding. */
        padding?: number;
        classes?: string[];
    };
}

export declare const Progress: DefineComponent<ProgressProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ProgressProps> & Readonly<{}>, {
value: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare interface ProgressProps {
    /** The current value of the progress bar, expressed as a percentage. The value should be between 0 and 100. */
    value?: number;
}

export declare const Radio: DefineComponent<RadioProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
input: (value: boolean) => any;
}, string, PublicProps, Readonly<RadioProps> & Readonly<{
onInput?: ((value: boolean) => any) | undefined;
}>, {
defaultChecked: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLLabelElement>;

/**
 * Renders a custom radio button, visually hiding the actual input while displaying custom icons for unchecked and checked states.
 * It supports all standard properties and events of an HTML input element of type "radio".
 */
export declare interface RadioProps extends /* @vue-ignore */ InputHTMLAttributes {
    defaultChecked?: boolean;
}

export declare const Rating: DefineComponent<RatingProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
change: (value: number) => any;
}, string, PublicProps, Readonly<RatingProps> & Readonly<{
onChange?: ((value: number) => any) | undefined;
}>, {
icon: Component;
value: number;
max: number;
precision: 0.1 | 0.2 | 0.25 | 0.5 | 1;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLLabelElement>;

/**
 * Renders a customizable rating component, allowing users to provide a rating by selecting a value using icons (e.g., stars).
 * Supports fractional ratings through precision control and allows for custom rating icon components.
 */
export declare interface RatingProps {
    /** The precision of the rating, determining the fraction of the star that can be selected. */
    precision?: 0.1 | 0.2 | 0.25 | 0.5 | 1;
    /** The maximum rating value, representing the number of icons displayed. */
    max?: number;
    /** The current value of the rating. */
    value?: number;
    /** The component used to render the rating icons. Defaults to a star icon. */
    icon?: Component;
}

export declare const RootRenderer: __VLS_WithTemplateSlots_64<typeof __VLS_component_54, __VLS_TemplateResult_54["slots"]>;

export declare const Section: __VLS_WithTemplateSlots_11<typeof __VLS_component_11, __VLS_TemplateResult_11["slots"]>;

export declare const SectionFooter: __VLS_WithTemplateSlots_13<typeof __VLS_component_13, __VLS_TemplateResult_13["slots"]>;

export declare interface SectionFooterProps {
    /** Centering text, adding additional indents */
    centered?: boolean;
}

export declare const SectionHeader: __VLS_WithTemplateSlots_12<typeof __VLS_component_12, __VLS_TemplateResult_12["slots"]>;

export declare interface SectionHeaderProps {
    /** Large title, changes font size, padding and color */
    large?: boolean;
}

export declare const SegmentedControl: __VLS_WithTemplateSlots_55<typeof __VLS_component_47, __VLS_TemplateResult_47["slots"]>;

export declare const SegmentedControlItem: __VLS_WithTemplateSlots_54<typeof __VLS_component_46, __VLS_TemplateResult_46["slots"]>;

/**
 * A component representing an individual item within a SegmentedControl.
 * It leverages the Tappable component for handling interactions and supports platform-specific styles.
 */
export declare interface SegmentedControlItemProps extends /* @vue-ignore */ ButtonHTMLAttributes {
    /** Whether the item is selected. Used by the parent SegmentedControl to style accordingly. */
    selected?: boolean;
}

export declare const Select: __VLS_WithTemplateSlots_36<DefineComponent<SelectProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SelectProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, Readonly<{
    /** Typically `option` elements to be rendered within the select. */
    default?: () => VNode[];
    /** Optional header content, displayed above the form input on `base` platform. */
    header?: () => VNode[];
    /** Content to be displayed before the form input, such as icons or labels. */
    before?: () => VNode[];
}> & {
    /** Typically `option` elements to be rendered within the select. */
    default?: () => VNode[];
    /** Optional header content, displayed above the form input on `base` platform. */
    header?: () => VNode[];
    /** Content to be displayed before the form input, such as icons or labels. */
    before?: () => VNode[];
}>;

export declare const Selectable: __VLS_WithTemplateSlots_42<DefineComponent<SelectableProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SelectableProps> & Readonly<{}>, {
defaultChecked: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

/**
 * Renders a custom styled selectable input (radio button), visually enhancing the default HTML input
 * with custom icons for both `iOS` and `base` platforms. It supports all standard properties and events
 * of an HTML input element of type "radio".
 *
 * The component determines the appropriate icon based on the operating platform, ensuring a consistent
 * user experience across different environments. The actual radio input is visually hidden while remaining
 * fully accessible and functional.
 */
export declare interface SelectableProps extends /* @vue-ignore */ InputHTMLAttributes {
    defaultChecked?: boolean;
}

export declare interface SelectProps extends /* @vue-ignore */ Attrs_5 {
}

export declare const Skeleton: __VLS_WithTemplateSlots_31<typeof __VLS_component_31, __VLS_TemplateResult_31["slots"]>;

/**
 * Used as a placeholder during the loading state of a component or page. It can visually mimic
 * the layout that will be replaced by the actual content once loaded, improving user experience by reducing perceived loading times.
 */
export declare interface SkeletonProps {
    /** If true, disables the shimmering animation of the skeleton. */
    withoutAnimation?: boolean;
    /** If true, the skeleton overlay is shown above the content. When false, the skeleton is hidden, showing any underlying content. */
    visible?: boolean;
}

export declare const Snackbar: __VLS_WithTemplateSlots_33<DefineComponent<SnackbarProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
close: () => any;
}, string, PublicProps, Readonly<SnackbarProps> & Readonly<{
onClose?: (() => any) | undefined;
}>, {
duration: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, Readonly<{
    /** Element or component to be displayed on the left side of the snackbar. */
    before?: () => VNode[];
    /** Element or component to be displayed on the right side of the snackbar. */
    after?: () => VNode[];
    /** The main content of the snackbar, typically text or a message. */
    default?: () => VNode[];
    /** Additional content displayed below the main message. */
    description?: () => VNode[];
    /** A link component to be included in the snackbar for user interaction. */
    link?: () => VNode[];
}> & {
    /** Element or component to be displayed on the left side of the snackbar. */
    before?: () => VNode[];
    /** Element or component to be displayed on the right side of the snackbar. */
    after?: () => VNode[];
    /** The main content of the snackbar, typically text or a message. */
    default?: () => VNode[];
    /** Additional content displayed below the main message. */
    description?: () => VNode[];
    /** A link component to be included in the snackbar for user interaction. */
    link?: () => VNode[];
}>;

export declare const SnackbarButton: __VLS_WithTemplateSlots_34<typeof __VLS_component_33, __VLS_TemplateResult_33["slots"]>;

export declare interface SnackbarButtonProps extends /* @vue-ignore */ ButtonHTMLAttributes {
}

/**
 * Displays a brief message at the bottom of the screen, which can contain actions and other content.
 * It automatically dismisses after a set duration, providing feedback or interaction prompts to users.
 */
export declare interface SnackbarProps {
    /** The duration in milliseconds after which the snackbar will automatically close. */
    duration?: number;
}

export declare const Spinner: DefineComponent<SpinnerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SpinnerProps> & Readonly<{}>, {
size: "s" | "m" | "l";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

/**
 * Provides a visual indicator for loading states across different platforms. It automatically selects
 * an appropriate spinner style based on the current platform, allowing for a consistent user experience.
 */
export declare interface SpinnerProps {
    /** Determines the size of the spinner. Can be 'small' (s), 'medium' (m), or 'large' (l), with 'medium' being the default size. */
    size: 's' | 'm' | 'l';
}

export declare const Spoiler: __VLS_WithTemplateSlots_32<typeof __VLS_component_32, __VLS_TemplateResult_32["slots"]>;

/**
 * Provides a way to hide or show content, such as details or spoilers, with a simple click.
 * The visibility state can be controlled externally via props or toggled by user interaction.
 */
export declare interface SpoilerProps {
    /** Controls the visibility of the content inside the spoiler. */
    visible?: boolean;
}

export declare const Steps: DefineComponent<StepsProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<StepsProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

/**
 * Renders a visual indicator of steps or progress in a process, such as a tutorial or a multi-step form.
 * It visually represents total steps and current progress.
 */
export declare interface StepsProps {
    /** Total number of steps. */
    count: number;
    /** Current progress, indicating how many steps have been completed. Progress is 0-indexed and goes up to `count`. */
    progress: number;
}

export declare const Subheadline: __VLS_WithTemplateSlots_69<typeof __VLS_component_59, __VLS_TemplateResult_59["slots"]>;

/**
 * The Subheadline component is designed to render text that serves as a secondary heading
 * or subheading within content. It leverages the Typography component for consistent text styling,
 * offering additional control over the text's size through the `level` prop. By default, it renders
 * as an `<h6>` element but can be customized with the `is` prop.
 */
declare type SubheadlineLevel = '1' | '2';

export declare interface SubheadlineProps extends /* @vue-ignore */ TypographyProps {
    /** Determines the size of the subheadline, with `1` being the default and `2` providing a smaller option. */
    level?: SubheadlineLevel;
}

export declare const Switch: __VLS_WithTemplateSlots_38<DefineComponent<SwitchProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SwitchProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, Readonly<{
    /** Text. */
    default?: () => VNode[];
}> & {
    /** Text. */
    default?: () => VNode[];
}>;

/**
 * A custom switch component that mimics the behavior of a checkbox input but with enhanced styling.
 * It supports all the standard attributes of an HTML input element of type "checkbox".
 * The appearance of the switch can be customized to match either a base or iOS platform style.
 */
export declare interface SwitchProps extends /* @vue-ignore */ InputHTMLAttributes {
}

export declare const Tabbar: __VLS_WithTemplateSlots_46<typeof __VLS_component_38, __VLS_TemplateResult_38["slots"]>;

export declare const TabbarItem: __VLS_WithTemplateSlots_45<typeof __VLS_component_37, __VLS_TemplateResult_37["slots"]>;

/**
 * Represents an individual tab within a `Tabbar`. Each `TabbarItem` typically contains an icon and optional text.
 * When selected, the tab exhibit different visual styles to indicate its active state.
 * The component adapts its styling based on the platform, providing a consistent look and feel across different devices.
 */
export declare interface TabbarItemProps extends /* @vue-ignore */ ButtonHTMLAttributes {
    /** Indicates whether the tab is selected or active. */
    selected?: boolean;
}

export declare const TabsList: __VLS_WithTemplateSlots_53<typeof __VLS_component_45, __VLS_TemplateResult_45["slots"]>;

export declare const TabsListItem: __VLS_WithTemplateSlots_52<typeof __VLS_component_44, __VLS_TemplateResult_44["slots"]>;

/**
 * TabsItem component represents an individual tab within a TabsList.
 * It can be interactively selected to display associated content.
 */
export declare interface TabsListItemProps extends /* @vue-ignore */ ButtonHTMLAttributes {
    /** Indicates if the tab item is currently selected. */
    selected?: boolean;
}

export declare const Tappable: __VLS_WithTemplateSlots_65<typeof __VLS_component_55, __VLS_TemplateResult_55["slots"]>;

export declare interface TappableProps {
    /** Component or HTML Tag */
    is?: Component | string;
    interactiveAnimation?: 'opacity' | 'background';
}

declare const Text_2: __VLS_WithTemplateSlots_70<typeof __VLS_component_60, __VLS_TemplateResult_60["slots"]>;
export { Text_2 as Text }

export declare const Textarea: __VLS_WithTemplateSlots_37<DefineComponent<TextareaProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TextareaProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, Readonly<{
    /** Textarea content. */
    default?: () => VNode[];
    /** Optional header content, displayed above the form input on `base` platform. */
    header?: () => VNode[];
}> & {
    /** Textarea content. */
    default?: () => VNode[];
    /** Optional header content, displayed above the form input on `base` platform. */
    header?: () => VNode[];
}>;

export declare interface TextareaProps extends /* @vue-ignore */ Attrs_6 {
}

/**
 * Text component is designed for general-purpose text rendering,
 * offering a wide range of typographic options. It extends the Typography
 * component, inheriting its flexibility and styling capabilities.
 * This component is ideal for paragraphs, labels, or any textual content, providing
 * consistent styling across the application.
 */
export declare interface TextProps extends /* @vue-ignore */ Omit<TypographyProps, 'plain'> {
}

export declare const Timeline: __VLS_WithTemplateSlots_14<typeof __VLS_component_14, __VLS_TemplateResult_14["slots"]>;

export declare const TimelineItem: __VLS_WithTemplateSlots_15<typeof __VLS_component_15, __VLS_TemplateResult_15["slots"]>;

export declare interface TimelineItemProps extends /* @vue-ignore */ LiHTMLAttributes {
    /** Internal prop, but you can change it. Marks line and dot of the item */
    mode?: 'active' | 'pre-active';
    /** If true, the item will be horizontal, passed from parent */
    horizontal?: boolean;
    /** Header of the item */
    header?: string;
}

/**
 * Renders a sequence of events or steps in either a vertical or horizontal layout. It is flexible,
 * supporting an active state to visually distinguish past, present, and future steps.
 */
export declare interface TimelineProps {
    /** Determines the orientation of the timeline. If true, the timeline is displayed horizontally. */
    horizontal?: boolean;
    /** The index of the active item in the timeline, which affects styling to indicate progress. */
    active?: number;
}

export declare const Title: __VLS_WithTemplateSlots_71<typeof __VLS_component_61, __VLS_TemplateResult_61["slots"]>;

/**
 * The Title component is designed to render text as a page or section heading,
 * providing clear hierarchy and structure within content. It supports three levels of emphasis,
 * allowing for flexibility in design while maintaining semantic integrity. By default, it uses `h3`
 * for its semantic HTML element but can be customized via the `level` prop or explicitly with the `is` prop.
 */
declare type TitleLevel = '1' | '2' | '3';

export declare interface TitleProps extends /* @vue-ignore */ TypographyProps {
    /** Determines the size and semantic tag of the title, with options for `h2`, `h3`, or `h4`. */
    level?: TitleLevel;
}

export declare const Tooltip: __VLS_WithTemplateSlots_60<typeof __VLS_component_50, __VLS_TemplateResult_50["slots"]>;

/**
 * The Tooltip component provides text labels that appear when the user hovers over, focuses on,
 * or touches an element. It's built on top of the Popper component for automatic positioning
 * relative to the target element. The tooltip supports light and dark modes for different visual
 * contexts and uses the Caption component for its content to ensure consistent typography.
 */
export declare interface TooltipProps extends /* @vue-ignore */ PopperProps {
    /** Defines the theme of the tooltip, affecting its background and text color. */
    mode?: 'light' | 'dark';
}

export declare const Typography: __VLS_WithTemplateSlots_72<typeof __VLS_component_62, __VLS_TemplateResult_62["slots"]>;

/**
 * The Typography component is a versatile wrapper for text content, offering
 * customizable styling options such as weight, capitalization, and HTML tag. It's designed
 * to facilitate consistent text styling across your application, with support for customization
 * through props. The component is highly reusable and adaptable to various design needs.
 */
export declare interface TypographyProps {
    /** Controls the font weight of the text, with options ranging from light to bold. */
    weight?: '1' | '2' | '3';
    /** If true, transforms the text to uppercase for stylistic emphasis. */
    caps?: boolean;
    /** Specifies the HTML tag used to render the text. */
    is?: string;
    /** When true, removes the default margins around the text, useful for inline styling or custom layouts. */
    plain?: boolean;
}

declare interface UseFloatingMiddlewaresConfig {
    /** By default, the component will automatically choose the best placement */
    placement?: PlacementWithAuto;
    /** Offset along the main axis. */
    offsetByMainAxis?: number;
    /** Offset along the cross axis. */
    offsetByCrossAxis?: number;
    /** Ref for arrow element */
    arrowRef?: ArrowOptions['element'];
    /** Whether to display an arrow pointing to the anchor element. */
    withArrow?: boolean;
    /** The height of the arrow. This is added to `mainAxis` to prevent the arrow from overlapping the anchor element. */
    arrowHeight?: number;
    /** A safe zone around the arrow to prevent it from exceeding the content bounds. */
    arrowPadding?: number;
    /** Sets the width to match the target element. */
    sameWidth?: boolean;
    /** An array of custom modifiers for Popper (should be memoized). */
    customMiddlewares?: Middleware[];
}

declare interface UsePaginationConfig {
    /** Number of always visible pages at the beginning and end. */
    boundaryCount: MaybeRef<number | undefined>;
    /** The total number of pages. */
    count: MaybeRef<number | undefined>;
    /** The page selected by default when the component is uncontrolled */
    defaultPage: MaybeRef<number | undefined>;
    /** If `true`, hide the next-page button. */
    hideNextButton: MaybeRef<boolean | undefined>;
    /** If `true`, hide the previous-page button. */
    hidePrevButton: MaybeRef<boolean | undefined>;
    /** The current page. */
    page: MaybeRef<number | undefined>;
    /** Number of always visible pages before and after the current page. */
    siblingCount: MaybeRef<number | undefined>;
    /** Callback to be fired when value changed. */
    onChange?: OnChange;
}

export declare const VisuallyHidden: __VLS_WithTemplateSlots_62<typeof __VLS_component_52, __VLS_TemplateResult_52["slots"]>;

export declare interface VisuallyHiddenProps {
    is?: string;
}

export { }