import { AllowedComponentProps } from 'vue';
import { App } from 'vue';
import { Component } from 'vue';
import { ComponentCustomProps } from 'vue';
import { ComponentOptionsBase } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { ComputedRef } from 'vue';
import { CreateComponentPublicInstanceWithMixins } from 'vue';
import { DefineComponent } from 'vue';
import { DefineSetupFnComponent } from 'vue';
import { DialogCloseProps } from 'reka-ui';
import { DialogContentProps } from 'reka-ui';
import { DialogDescriptionProps } from 'reka-ui';
import { DialogRootProps } from 'reka-ui';
import { DialogTitleProps } from 'reka-ui';
import { DialogTriggerProps } from 'reka-ui';
import { ExtractPropTypes } from 'vue';
import { FocusOutsideEvent } from 'reka-ui';
import { GlobalComponents } from 'vue';
import { GlobalDirectives } from 'vue';
import { HTMLAttributes } from 'vue';
import { PointerDownOutsideEvent } from 'reka-ui';
import { PopoverContentProps } from 'reka-ui';
import { PopoverRootProps } from 'reka-ui';
import { PopoverTriggerProps } from 'reka-ui';
import { PublicProps } from 'vue';
import { Ref } from 'vue';
import { SchemeColor } from '../types/scheme-colors';
import { SchemeColor as SchemeColor_2 } from '../../types/scheme-colors';
import { TabsContentProps } from 'reka-ui';
import { TabsListProps } from 'reka-ui';
import { TabsRootProps } from 'reka-ui';
import { TabsTriggerProps } from 'reka-ui';
import { TooltipContentProps } from 'reka-ui';
import { VNodeNormalizedChildren } from 'vue';
import { VNodeProps } from 'vue';

declare interface AudioTranscriptionButtonProps {
    active: boolean;
    enableGenerateTranscription: boolean;
    transcriptionTooltipText: string;
}

declare interface AvatarIconProps {
    enabled?: boolean;
    icon?: string;
    size?: AvatarIconSize;
    scheme?: SchemeColor;
    filled?: boolean;
    opacity?: boolean;
}

declare type AvatarIconSize = 'nano' | 'xs' | 'sm' | 'lg' | 'xl';

declare interface BreadcrumbItem {
    name: string;
}

declare interface BreadcrumbProps {
    crumbs?: BreadcrumbItem[] | null;
}

declare interface ButtonProps {
    size?: ButtonSize;
    text?: string;
    type?: ButtonType;
    float?: boolean;
    iconLeft?: string;
    iconRight?: string;
    iconCenter?: string;
    iconsFilled?: boolean;
    disabled?: boolean;
    loading?: boolean;
    pressed?: boolean;
}

declare type ButtonSize = 'small' | 'large' | 'extra-large';

declare type ButtonType = 'primary' | 'secondary' | 'tertiary' | 'warning' | 'attention';

declare interface CheckboxGroupProps {
    state?: 'horizontal' | 'vertical';
    label?: string;
    labelTooltip?: TooltipProps;
    helper?: string;
}

declare interface CheckboxProps {
    modelValue?: CheckboxValue;
    disabled?: boolean;
    label?: string;
    helper?: string;
    textRight?: string;
}

declare type CheckboxValue = boolean | 'less';

declare interface ChipProps {
    isSelected?: boolean;
    text?: string;
    count?: number;
    type: 'single' | 'multiple';
    isClickable?: boolean;
    onClick?: (event: Event) => void;
}

export declare const components: ComponentsMap;

export declare interface ComponentsMap {
    [key: string]: VueComponent | Function;
}

declare interface DateCell {
    properties: DateCellProperty[];
    date?: string | number;
    toString: () => string;
}

declare type DateCellProperty = 'inside month' | 'out of range' | 'selected' | 'left-highlighted' | 'right-highlighted' | 'highlighted' | 'today' | string;

declare interface DatePickerProps {
    initialStartDate?: string;
    initialEndDate?: string;
    minDate?: string;
    maxDate?: string;
    periodBaseDate?: string;
    equivalentOption?: string;
    type?: 'day' | 'month' | 'year';
    size?: 'small' | 'large';
    clearLabel?: string;
    actionLabel?: string;
    months?: string[];
    days?: string[];
    options?: PeriodOption[];
    disableClear?: boolean;
    hideOptions?: boolean;
    locale?: string;
    translations?: DatePickerTranslations;
    variant?: 'card' | 'popover';
}

declare type DatePickerTranslations = Record<string, string | Record<string, string>>;

declare interface DisclaimerProps {
    title?: string;
    description?: string;
    type?: DisclaimerType;
    icon?: string | undefined;
    iconColor?: SchemeColor_2 | undefined;
}

declare type DisclaimerType = 'informational' | 'success' | 'attention' | 'error' | 'neutral';

/**
 * Self-contained props type that mirrors `vaul-vue`'s `DrawerRootProps`.
 *
 * We intentionally avoid extending or intersecting `DrawerRootProps` because
 * its definition includes the internal, non-exported `WithoutFadeFromProps`
 * type, which breaks `vite-plugin-dts` declaration rollup with TS4023 when
 * combined with our extra `lazyMount` / `unmountDelay` props.
 */
declare interface DrawerRootProps {
    activeSnapPoint?: number | string | null;
    closeThreshold?: number;
    shouldScaleBackground?: boolean;
    setBackgroundColorOnScale?: boolean;
    scrollLockTimeout?: number;
    fixed?: boolean;
    dismissible?: boolean;
    modal?: boolean;
    open?: boolean;
    defaultOpen?: boolean;
    nested?: boolean;
    direction?: 'top' | 'bottom' | 'left' | 'right';
    noBodyStyles?: boolean;
    handleOnly?: boolean;
    preventScrollRestoration?: boolean;
    snapPoints?: (number | string)[];
}

declare interface FormElementProps {
    size?: 'md' | 'sm';
    label?: string;
    fixedLabel?: boolean;
    error?: string;
    message?: string;
    disabled?: boolean;
    tooltip?: TooltipProps;
}

declare interface IconProps {
    filled?: boolean;
    icon?: string | null;
    clickable?: boolean;
    size?: IconSize;
    scheme?: SchemeColor_2;
}

declare type IconSize = 'nano' | 'xs' | 'sm' | 'ant' | 'md' | 'lg' | 'xl' | 'avatar-lg' | 'avatar-md' | 'avatar-sm' | 'avatar-xs' | 'avatar-nano';

declare interface InputProps {
    placeholder?: string;
    type?: InputVariant;
    modelValue?: string;
    nativeType?: string;
    message?: string;
    errors?: string | string[];
    label?: string;
    iconLeft?: string;
    iconRight?: string;
    allowTogglePassword?: boolean;
    iconLeftClickable?: boolean;
    iconRightClickable?: boolean;
    hasCloudyColor?: boolean;
    size?: InputSize | string;
    mask?: string | string[];
    tooltip?: TooltipProps;
    maxlength?: number | null;
    showMaxlengthCounter?: boolean;
    disabled?: boolean;
    readonly?: boolean;
    useFocusProp?: boolean;
    focus?: boolean;
    showClear?: boolean;
}

declare type InputSize = 'md' | 'sm';

declare type InputVariant = 'normal' | 'error';

declare interface PageHeaderProps {
    title: string;
    description?: string;
    hasBackButton?: boolean;
    hideDivider?: boolean;
}

declare interface PaginationProps {
    modelValue?: number;
    max?: number;
    show?: number;
    disabled?: boolean;
}

declare type PeriodOption = {
    id: string;
    name: string;
};

declare interface Props {
    returnName?: boolean;
    position?: 'top' | 'bottom';
    locale?: string;
}

declare interface RadioGroupProps {
    modelValue?: string | number;
    state?: 'horizontal' | 'vertical';
    label?: string;
    labelTooltip?: TooltipProps;
    name?: string;
    helper?: string;
}

declare interface RadioProps {
    modelValue?: string | number;
    value?: string | number;
    disabled?: boolean;
    label?: string;
    name?: string;
    helper?: string;
}

declare interface SelectItemProps {
    size?: string;
    selectable?: boolean;
    active?: boolean;
    textFocused?: boolean;
}

declare interface SkeletonLoadingProps {
    prefix?: string;
    count?: number;
    duration?: number;
    tag?: string;
    width?: string | number;
    height?: string | number;
    circle?: boolean;
    loading?: boolean;
    direct?: boolean;
}

declare interface SwitchProps {
    size?: 'small' | 'medium';
    label?: string;
    labelTooltip?: TooltipProps;
    option?: string;
    helper?: string;
    textLeft?: string;
    textRight?: string;
    disabled?: boolean;
    modelValue?: boolean;
}

declare interface TagProps {
    type?: TagType;
    size?: TagSize;
    text?: string;
    disabled?: boolean;
    scheme?: string;
    leftIcon?: string;
    hasCloseIcon?: boolean;
}

declare type TagSize = 'small' | 'medium';

declare type TagType = 'default' | 'brand' | 'next';

declare type TeleportTarget = string | HTMLElement;

declare interface TextAreaProps {
    size?: 'md' | 'sm';
    resize?: 'none' | 'vertical';
    label?: string;
    placeholder?: string;
    modelValue?: string;
    maxLength?: number;
    message?: string;
    disabled?: boolean;
    type?: 'normal' | 'error';
    tooltip?: TooltipProps;
    errors?: string | string[];
}

export declare type Theme = 'light' | 'dark';

export declare type ThemePreference = Theme | 'system';

declare interface ToastButton {
    text: string;
    action: () => void;
}

declare interface ToastCall {
    info: (title: string, description?: string, options?: ToastOptions) => Promise<void>;
    success: (title: string, description?: string, options?: ToastOptions) => Promise<void>;
    attention: (title: string, description?: string, options?: ToastOptions) => Promise<void>;
    error: (title: string, description?: string, options?: ToastOptions) => Promise<void>;
}

declare interface ToastOptions {
    type?: ToastType;
    button?: ToastButton;
    timeout?: number;
}

declare interface ToastProps extends ToastOptions {
    title: string;
    description?: string;
}

declare type ToastType = 'informational' | 'attention' | 'success' | 'error';

declare interface TooltipProps {
    text?: string;
    enabled?: boolean;
    forceOpen?: boolean;
    side?: 'top' | 'right' | 'bottom' | 'left';
    maxWidth?: string;
    enableHtml?: boolean;
    showClose?: boolean;
    class?: string;
    contentProps?: Partial<TooltipContentProps>;
}

declare const Unnnic: UnnnicPlugin;
export default Unnnic;

export declare const UnnnicAccordion: DefineComponent<ExtractPropTypes<    {
open: {
type: BooleanConstructor;
default: boolean;
};
title: {
type: StringConstructor;
};
}>, {}, {
height: number;
setHeightToNull: null;
}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
open: {
type: BooleanConstructor;
default: boolean;
};
title: {
type: StringConstructor;
};
}>> & Readonly<{}>, {
open: boolean;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicAccordion: DefineComponent<ExtractPropTypes<    {
open: {
type: BooleanConstructor;
default: boolean;
};
title: {
type: StringConstructor;
};
}>, {}, {
height: number;
setHeightToNull: null;
}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
open: {
type: BooleanConstructor;
default: boolean;
};
title: {
type: StringConstructor;
};
}>> & Readonly<{}>, {
open: boolean;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicAlert: DefineComponent<ExtractPropTypes<    {
version: {
type: StringConstructor;
default: string;
};
text: {
type: StringConstructor;
default: null;
};
scheme: {
type: StringConstructor;
default: null;
};
onClose: {
type: FunctionConstructor;
default: () => void;
};
type: {
type: StringConstructor;
default: string;
};
}>, {}, {}, {
toastType(): "error" | "attention" | "informational" | "success";
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
version: {
type: StringConstructor;
default: string;
};
text: {
type: StringConstructor;
default: null;
};
scheme: {
type: StringConstructor;
default: null;
};
onClose: {
type: FunctionConstructor;
default: () => void;
};
type: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
type: string;
text: string;
scheme: string;
version: string;
onClose: Function;
}, {}, {
UnnnicToast: DefineComponent<ToastProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
close: () => any;
destroy: () => any;
}, string, PublicProps, Readonly<ToastProps> & Readonly<{
onClose?: (() => any) | undefined;
onDestroy?: (() => any) | undefined;
}>, {
type: ToastType;
button: ToastButton;
title: string;
description: string;
timeout: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
Version1dot1: DefineComponent<ExtractPropTypes<    {
text: {
type: StringConstructor;
default: null;
};
scheme: {
type: StringConstructor;
default: null;
};
onClose: {
type: FunctionConstructor;
default: () => void;
};
type: {
type: StringConstructor;
default: string;
};
}>, {}, {}, {}, {
emitClose(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, "close"[], "close", PublicProps, Readonly<ExtractPropTypes<    {
text: {
type: StringConstructor;
default: null;
};
scheme: {
type: StringConstructor;
default: null;
};
onClose: {
type: FunctionConstructor;
default: () => void;
};
type: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
}>, {
type: string;
text: string;
scheme: string;
onClose: Function;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicAlert: DefineComponent<ExtractPropTypes<    {
version: {
type: StringConstructor;
default: string;
};
text: {
type: StringConstructor;
default: null;
};
scheme: {
type: StringConstructor;
default: null;
};
onClose: {
type: FunctionConstructor;
default: () => void;
};
type: {
type: StringConstructor;
default: string;
};
}>, {}, {}, {
toastType(): "error" | "attention" | "informational" | "success";
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
version: {
type: StringConstructor;
default: string;
};
text: {
type: StringConstructor;
default: null;
};
scheme: {
type: StringConstructor;
default: null;
};
onClose: {
type: FunctionConstructor;
default: () => void;
};
type: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
type: string;
text: string;
scheme: string;
version: string;
onClose: Function;
}, {}, {
UnnnicToast: DefineComponent<ToastProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
close: () => any;
destroy: () => any;
}, string, PublicProps, Readonly<ToastProps> & Readonly<{
onClose?: (() => any) | undefined;
onDestroy?: (() => any) | undefined;
}>, {
type: ToastType;
button: ToastButton;
title: string;
description: string;
timeout: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
Version1dot1: DefineComponent<ExtractPropTypes<    {
text: {
type: StringConstructor;
default: null;
};
scheme: {
type: StringConstructor;
default: null;
};
onClose: {
type: FunctionConstructor;
default: () => void;
};
type: {
type: StringConstructor;
default: string;
};
}>, {}, {}, {}, {
emitClose(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, "close"[], "close", PublicProps, Readonly<ExtractPropTypes<    {
text: {
type: StringConstructor;
default: null;
};
scheme: {
type: StringConstructor;
default: null;
};
onClose: {
type: FunctionConstructor;
default: () => void;
};
type: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
}>, {
type: string;
text: string;
scheme: string;
onClose: Function;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicAudioRecorder: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: {
new (): HTMLAudioElement;
prototype: HTMLAudioElement;
};
required: true;
};
src: {
type: StringConstructor;
default: undefined;
};
canDiscard: {
type: BooleanConstructor;
default: boolean;
};
reqStatus: {
type: StringConstructor;
default: string;
validate(status: any): boolean;
};
playbackAudioBars: {
type: BooleanConstructor;
default: boolean;
};
showTranscriptionAction: {
type: BooleanConstructor;
default: boolean;
};
enableGenerateTranscription: {
type: BooleanConstructor;
default: boolean;
};
showTranscriptionText: {
type: BooleanConstructor;
default: boolean;
};
isLoadingTranscription: {
type: BooleanConstructor;
default: boolean;
};
transcriptionText: {
type: StringConstructor;
default: string;
};
locale: {
type: StringConstructor;
default: string;
};
fluidBar: {
type: BooleanConstructor;
default: boolean;
};
saveText: {
type: StringConstructor;
default: string;
};
discardText: {
type: StringConstructor;
default: string;
};
hideRecordingIndicator: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {
recorder: MediaRecorder;
audio: HTMLAudioElement;
stream: MediaStream;
audioChunks: never[];
duration: number;
currentTime: number;
mockMilliseconds: number;
intervalMockMilliseconds: null;
status: ("idle" | "recording" | "recorded" | "playing" | "paused");
bars: never[];
}, {
isIdle(): boolean;
isPlaying(): boolean;
isRecording(): boolean;
isRecorded(): boolean;
playedPercentual(): number;
}, {
getBlobDuration(blob: any): Promise<any>;
record(): Promise<void>;
hasInUseRecordDevice(): true;
getAudioRecordDevice(): Promise<void>;
setupRecorderAndAudio(): Promise<void>;
addListeners(): void;
addAudioEventListeners(): void;
startMockMilliseconds(): void;
stopMockMilliseconds(): void;
startRecord(): void;
discard(): void;
save(): void;
pause(): void;
stop(): void;
play(): void;
progressBarUpdate(event: any): void;
srcToBars(src: any): Promise<any>;
numberToTimeString(time: any): string;
}, ComponentOptionsMixin, ComponentOptionsMixin, ("update:model-value" | "status" | "failed-click" | "update:showTranscriptionText")[], "update:model-value" | "status" | "failed-click" | "update:showTranscriptionText", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: {
new (): HTMLAudioElement;
prototype: HTMLAudioElement;
};
required: true;
};
src: {
type: StringConstructor;
default: undefined;
};
canDiscard: {
type: BooleanConstructor;
default: boolean;
};
reqStatus: {
type: StringConstructor;
default: string;
validate(status: any): boolean;
};
playbackAudioBars: {
type: BooleanConstructor;
default: boolean;
};
showTranscriptionAction: {
type: BooleanConstructor;
default: boolean;
};
enableGenerateTranscription: {
type: BooleanConstructor;
default: boolean;
};
showTranscriptionText: {
type: BooleanConstructor;
default: boolean;
};
isLoadingTranscription: {
type: BooleanConstructor;
default: boolean;
};
transcriptionText: {
type: StringConstructor;
default: string;
};
locale: {
type: StringConstructor;
default: string;
};
fluidBar: {
type: BooleanConstructor;
default: boolean;
};
saveText: {
type: StringConstructor;
default: string;
};
discardText: {
type: StringConstructor;
default: string;
};
hideRecordingIndicator: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
"onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
"onFailed-click"?: ((...args: any[]) => any) | undefined;
"onUpdate:showTranscriptionText"?: ((...args: any[]) => any) | undefined;
onStatus?: ((...args: any[]) => any) | undefined;
}>, {
locale: string;
src: string;
saveText: string;
hideRecordingIndicator: boolean;
enableGenerateTranscription: boolean;
reqStatus: string;
showTranscriptionAction: boolean;
isLoadingTranscription: boolean;
showTranscriptionText: boolean;
transcriptionText: string;
fluidBar: boolean;
canDiscard: boolean;
playbackAudioBars: boolean;
discardText: string;
}, {}, {
AudioHandler: DefineComponent<ExtractPropTypes<    {
isRecording: {
type: BooleanConstructor;
default: boolean;
};
time: {
type: StringConstructor;
default: string;
};
saveText: {
type: StringConstructor;
default: string;
};
hideRecordingIndicator: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {
defaultTranslations: {
save: {
'pt-br': string;
en: string;
es: string;
};
};
}, {}, {
save(): void;
}, {
props: {
locale: {
type: StringConstructor;
};
translations: {
type: ObjectConstructor;
};
};
methods: {
i18n(...args: any[]): any;
};
}, ComponentOptionsMixin, "save"[], "save", PublicProps, Readonly<ExtractPropTypes<    {
isRecording: {
type: BooleanConstructor;
default: boolean;
};
time: {
type: StringConstructor;
default: string;
};
saveText: {
type: StringConstructor;
default: string;
};
hideRecordingIndicator: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onSave?: ((...args: any[]) => any) | undefined;
}>, {
time: string;
isRecording: boolean;
saveText: string;
hideRecordingIndicator: boolean;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
UnnnicToolTip: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, PublicProps, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, string, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, ComponentProvideOptions, true, {}, any>;
AudioPlayer: DefineComponent<ExtractPropTypes<    {
time: {
type: StringConstructor;
default: string;
};
duration: {
type: StringConstructor;
default: string;
};
reqStatus: {
type: StringConstructor;
default: string;
validate(status: any): boolean;
};
isPlaying: {
type: BooleanConstructor;
default: boolean;
};
progressBarPercentualValue: {
type: NumberConstructor;
default: number;
};
bars: {
type: ArrayConstructor;
required: true;
};
showTranscriptionAction: {
type: BooleanConstructor;
default: boolean;
};
enableGenerateTranscription: {
type: BooleanConstructor;
default: boolean;
};
isLoadingTranscription: {
type: BooleanConstructor;
default: boolean;
};
showTranscriptionText: {
type: BooleanConstructor;
default: boolean;
};
transcriptionText: {
type: StringConstructor;
default: string;
};
locale: {
type: StringConstructor;
default: string;
};
fluidBar: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {
progress: number;
defaultTranslations: {
show_transcription: {
'pt-br': string;
en: string;
es: string;
};
hide_transcription: {
'pt-br': string;
en: string;
es: string;
};
unavailable_transcription: {
'pt-br': string;
en: string;
es: string;
};
loading_transcription: {
'pt-br': string;
en: string;
es: string;
};
};
}, {
showProgressBar(): boolean;
playbackIcon(): any;
transcriptionTooltipText(): any;
progressBarStyle(): {
'--progressBarPercentualValue': string;
};
}, {
clickTranscription(): void;
click(): void;
togglePlayback(): void;
play(): void;
pause(): void;
emitProgressBarUpdate(event: any): void;
isBarActive(index: any): boolean;
}, {
props: {
locale: {
type: StringConstructor;
};
translations: {
type: ObjectConstructor;
};
};
methods: {
i18n(...args: any[]): any;
};
}, ComponentOptionsMixin, ("pause" | "play" | "progress-bar-update" | "failed-click" | "update:showTranscriptionText")[], "pause" | "play" | "progress-bar-update" | "failed-click" | "update:showTranscriptionText", PublicProps, Readonly<ExtractPropTypes<    {
time: {
type: StringConstructor;
default: string;
};
duration: {
type: StringConstructor;
default: string;
};
reqStatus: {
type: StringConstructor;
default: string;
validate(status: any): boolean;
};
isPlaying: {
type: BooleanConstructor;
default: boolean;
};
progressBarPercentualValue: {
type: NumberConstructor;
default: number;
};
bars: {
type: ArrayConstructor;
required: true;
};
showTranscriptionAction: {
type: BooleanConstructor;
default: boolean;
};
enableGenerateTranscription: {
type: BooleanConstructor;
default: boolean;
};
isLoadingTranscription: {
type: BooleanConstructor;
default: boolean;
};
showTranscriptionText: {
type: BooleanConstructor;
default: boolean;
};
transcriptionText: {
type: StringConstructor;
default: string;
};
locale: {
type: StringConstructor;
default: string;
};
fluidBar: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onPause?: ((...args: any[]) => any) | undefined;
onPlay?: ((...args: any[]) => any) | undefined;
"onProgress-bar-update"?: ((...args: any[]) => any) | undefined;
"onFailed-click"?: ((...args: any[]) => any) | undefined;
"onUpdate:showTranscriptionText"?: ((...args: any[]) => any) | undefined;
}>, {
time: string;
locale: string;
duration: string;
enableGenerateTranscription: boolean;
reqStatus: string;
isPlaying: boolean;
progressBarPercentualValue: number;
showTranscriptionAction: boolean;
isLoadingTranscription: boolean;
showTranscriptionText: boolean;
transcriptionText: string;
fluidBar: boolean;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
AudioTranscriptionButton: DefineComponent<AudioTranscriptionButtonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: () => any;
}, string, PublicProps, Readonly<AudioTranscriptionButtonProps> & Readonly<{
onClick?: (() => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
}, {}, string, ComponentProvideOptions, true, {}, any>;
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
UnnnicToolTip: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, PublicProps, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, string, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicAudioRecorder: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: {
new (): HTMLAudioElement;
prototype: HTMLAudioElement;
};
required: true;
};
src: {
type: StringConstructor;
default: undefined;
};
canDiscard: {
type: BooleanConstructor;
default: boolean;
};
reqStatus: {
type: StringConstructor;
default: string;
validate(status: any): boolean;
};
playbackAudioBars: {
type: BooleanConstructor;
default: boolean;
};
showTranscriptionAction: {
type: BooleanConstructor;
default: boolean;
};
enableGenerateTranscription: {
type: BooleanConstructor;
default: boolean;
};
showTranscriptionText: {
type: BooleanConstructor;
default: boolean;
};
isLoadingTranscription: {
type: BooleanConstructor;
default: boolean;
};
transcriptionText: {
type: StringConstructor;
default: string;
};
locale: {
type: StringConstructor;
default: string;
};
fluidBar: {
type: BooleanConstructor;
default: boolean;
};
saveText: {
type: StringConstructor;
default: string;
};
discardText: {
type: StringConstructor;
default: string;
};
hideRecordingIndicator: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {
recorder: MediaRecorder;
audio: HTMLAudioElement;
stream: MediaStream;
audioChunks: never[];
duration: number;
currentTime: number;
mockMilliseconds: number;
intervalMockMilliseconds: null;
status: ("idle" | "recording" | "recorded" | "playing" | "paused");
bars: never[];
}, {
isIdle(): boolean;
isPlaying(): boolean;
isRecording(): boolean;
isRecorded(): boolean;
playedPercentual(): number;
}, {
getBlobDuration(blob: any): Promise<any>;
record(): Promise<void>;
hasInUseRecordDevice(): true;
getAudioRecordDevice(): Promise<void>;
setupRecorderAndAudio(): Promise<void>;
addListeners(): void;
addAudioEventListeners(): void;
startMockMilliseconds(): void;
stopMockMilliseconds(): void;
startRecord(): void;
discard(): void;
save(): void;
pause(): void;
stop(): void;
play(): void;
progressBarUpdate(event: any): void;
srcToBars(src: any): Promise<any>;
numberToTimeString(time: any): string;
}, ComponentOptionsMixin, ComponentOptionsMixin, ("update:model-value" | "status" | "failed-click" | "update:showTranscriptionText")[], "update:model-value" | "status" | "failed-click" | "update:showTranscriptionText", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: {
new (): HTMLAudioElement;
prototype: HTMLAudioElement;
};
required: true;
};
src: {
type: StringConstructor;
default: undefined;
};
canDiscard: {
type: BooleanConstructor;
default: boolean;
};
reqStatus: {
type: StringConstructor;
default: string;
validate(status: any): boolean;
};
playbackAudioBars: {
type: BooleanConstructor;
default: boolean;
};
showTranscriptionAction: {
type: BooleanConstructor;
default: boolean;
};
enableGenerateTranscription: {
type: BooleanConstructor;
default: boolean;
};
showTranscriptionText: {
type: BooleanConstructor;
default: boolean;
};
isLoadingTranscription: {
type: BooleanConstructor;
default: boolean;
};
transcriptionText: {
type: StringConstructor;
default: string;
};
locale: {
type: StringConstructor;
default: string;
};
fluidBar: {
type: BooleanConstructor;
default: boolean;
};
saveText: {
type: StringConstructor;
default: string;
};
discardText: {
type: StringConstructor;
default: string;
};
hideRecordingIndicator: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
"onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
"onFailed-click"?: ((...args: any[]) => any) | undefined;
"onUpdate:showTranscriptionText"?: ((...args: any[]) => any) | undefined;
onStatus?: ((...args: any[]) => any) | undefined;
}>, {
locale: string;
src: string;
saveText: string;
hideRecordingIndicator: boolean;
enableGenerateTranscription: boolean;
reqStatus: string;
showTranscriptionAction: boolean;
isLoadingTranscription: boolean;
showTranscriptionText: boolean;
transcriptionText: string;
fluidBar: boolean;
canDiscard: boolean;
playbackAudioBars: boolean;
discardText: string;
}, {}, {
AudioHandler: DefineComponent<ExtractPropTypes<    {
isRecording: {
type: BooleanConstructor;
default: boolean;
};
time: {
type: StringConstructor;
default: string;
};
saveText: {
type: StringConstructor;
default: string;
};
hideRecordingIndicator: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {
defaultTranslations: {
save: {
'pt-br': string;
en: string;
es: string;
};
};
}, {}, {
save(): void;
}, {
props: {
locale: {
type: StringConstructor;
};
translations: {
type: ObjectConstructor;
};
};
methods: {
i18n(...args: any[]): any;
};
}, ComponentOptionsMixin, "save"[], "save", PublicProps, Readonly<ExtractPropTypes<    {
isRecording: {
type: BooleanConstructor;
default: boolean;
};
time: {
type: StringConstructor;
default: string;
};
saveText: {
type: StringConstructor;
default: string;
};
hideRecordingIndicator: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onSave?: ((...args: any[]) => any) | undefined;
}>, {
time: string;
isRecording: boolean;
saveText: string;
hideRecordingIndicator: boolean;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
UnnnicToolTip: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, PublicProps, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, string, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, ComponentProvideOptions, true, {}, any>;
AudioPlayer: DefineComponent<ExtractPropTypes<    {
time: {
type: StringConstructor;
default: string;
};
duration: {
type: StringConstructor;
default: string;
};
reqStatus: {
type: StringConstructor;
default: string;
validate(status: any): boolean;
};
isPlaying: {
type: BooleanConstructor;
default: boolean;
};
progressBarPercentualValue: {
type: NumberConstructor;
default: number;
};
bars: {
type: ArrayConstructor;
required: true;
};
showTranscriptionAction: {
type: BooleanConstructor;
default: boolean;
};
enableGenerateTranscription: {
type: BooleanConstructor;
default: boolean;
};
isLoadingTranscription: {
type: BooleanConstructor;
default: boolean;
};
showTranscriptionText: {
type: BooleanConstructor;
default: boolean;
};
transcriptionText: {
type: StringConstructor;
default: string;
};
locale: {
type: StringConstructor;
default: string;
};
fluidBar: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {
progress: number;
defaultTranslations: {
show_transcription: {
'pt-br': string;
en: string;
es: string;
};
hide_transcription: {
'pt-br': string;
en: string;
es: string;
};
unavailable_transcription: {
'pt-br': string;
en: string;
es: string;
};
loading_transcription: {
'pt-br': string;
en: string;
es: string;
};
};
}, {
showProgressBar(): boolean;
playbackIcon(): any;
transcriptionTooltipText(): any;
progressBarStyle(): {
'--progressBarPercentualValue': string;
};
}, {
clickTranscription(): void;
click(): void;
togglePlayback(): void;
play(): void;
pause(): void;
emitProgressBarUpdate(event: any): void;
isBarActive(index: any): boolean;
}, {
props: {
locale: {
type: StringConstructor;
};
translations: {
type: ObjectConstructor;
};
};
methods: {
i18n(...args: any[]): any;
};
}, ComponentOptionsMixin, ("pause" | "play" | "progress-bar-update" | "failed-click" | "update:showTranscriptionText")[], "pause" | "play" | "progress-bar-update" | "failed-click" | "update:showTranscriptionText", PublicProps, Readonly<ExtractPropTypes<    {
time: {
type: StringConstructor;
default: string;
};
duration: {
type: StringConstructor;
default: string;
};
reqStatus: {
type: StringConstructor;
default: string;
validate(status: any): boolean;
};
isPlaying: {
type: BooleanConstructor;
default: boolean;
};
progressBarPercentualValue: {
type: NumberConstructor;
default: number;
};
bars: {
type: ArrayConstructor;
required: true;
};
showTranscriptionAction: {
type: BooleanConstructor;
default: boolean;
};
enableGenerateTranscription: {
type: BooleanConstructor;
default: boolean;
};
isLoadingTranscription: {
type: BooleanConstructor;
default: boolean;
};
showTranscriptionText: {
type: BooleanConstructor;
default: boolean;
};
transcriptionText: {
type: StringConstructor;
default: string;
};
locale: {
type: StringConstructor;
default: string;
};
fluidBar: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onPause?: ((...args: any[]) => any) | undefined;
onPlay?: ((...args: any[]) => any) | undefined;
"onProgress-bar-update"?: ((...args: any[]) => any) | undefined;
"onFailed-click"?: ((...args: any[]) => any) | undefined;
"onUpdate:showTranscriptionText"?: ((...args: any[]) => any) | undefined;
}>, {
time: string;
locale: string;
duration: string;
enableGenerateTranscription: boolean;
reqStatus: string;
isPlaying: boolean;
progressBarPercentualValue: number;
showTranscriptionAction: boolean;
isLoadingTranscription: boolean;
showTranscriptionText: boolean;
transcriptionText: string;
fluidBar: boolean;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
AudioTranscriptionButton: DefineComponent<AudioTranscriptionButtonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: () => any;
}, string, PublicProps, Readonly<AudioTranscriptionButtonProps> & Readonly<{
onClick?: (() => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
}, {}, string, ComponentProvideOptions, true, {}, any>;
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
UnnnicToolTip: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, PublicProps, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, string, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicAvatarIcon: DefineComponent<AvatarIconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AvatarIconProps> & Readonly<{}>, {
size: AvatarIconSize;
filled: boolean;
icon: string;
scheme: SchemeColor;
enabled: boolean;
opacity: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare const unnnicAvatarIcon: DefineComponent<AvatarIconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AvatarIconProps> & Readonly<{}>, {
size: AvatarIconSize;
filled: boolean;
icon: string;
scheme: SchemeColor;
enabled: boolean;
opacity: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare const UnnnicBanner: DefineComponent<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
validator(value: unknown): boolean;
};
firstTitle: {
type: StringConstructor;
default: null;
};
secondTitle: {
type: StringConstructor;
default: null;
};
thirdTitle: {
type: StringConstructor;
default: null;
};
firstDescription: {
type: StringConstructor;
default: null;
};
secondDescription: {
type: StringConstructor;
default: null;
};
thirdDescription: {
type: StringConstructor;
default: null;
};
subtitle: {
type: StringConstructor;
default: null;
};
rating: {
type: NumberConstructor;
default: number;
};
}>, {}, {}, {
currentComponent(): DefineComponent<ExtractPropTypes<    {
firstTitle: {
type: StringConstructor;
default: null;
};
secondTitle: {
type: StringConstructor;
default: null;
};
thirdTitle: {
type: StringConstructor;
default: null;
};
firstDescription: {
type: StringConstructor;
default: null;
};
secondDescription: {
type: StringConstructor;
default: null;
};
thirdDescription: {
type: StringConstructor;
default: null;
};
subtitle: {
type: StringConstructor;
default: null;
};
rating: {
type: NumberConstructor;
default: number;
};
}>, {}, {
tempRating: null;
baseRating: number;
}, {}, {
emitRatingAction(star: any): void;
starScheme(star: any): "fg-base" | "feedback-yellow";
starOver(star: any): void;
starOut(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
firstTitle: {
type: StringConstructor;
default: null;
};
secondTitle: {
type: StringConstructor;
default: null;
};
thirdTitle: {
type: StringConstructor;
default: null;
};
firstDescription: {
type: StringConstructor;
default: null;
};
secondDescription: {
type: StringConstructor;
default: null;
};
thirdDescription: {
type: StringConstructor;
default: null;
};
subtitle: {
type: StringConstructor;
default: null;
};
rating: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
rating: number;
subtitle: string;
firstTitle: string;
secondTitle: string;
thirdTitle: string;
firstDescription: string;
secondDescription: string;
thirdDescription: string;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;
}, {
emitRatingAction(star: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
validator(value: unknown): boolean;
};
firstTitle: {
type: StringConstructor;
default: null;
};
secondTitle: {
type: StringConstructor;
default: null;
};
thirdTitle: {
type: StringConstructor;
default: null;
};
firstDescription: {
type: StringConstructor;
default: null;
};
secondDescription: {
type: StringConstructor;
default: null;
};
thirdDescription: {
type: StringConstructor;
default: null;
};
subtitle: {
type: StringConstructor;
default: null;
};
rating: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
type: string;
rating: number;
subtitle: string;
firstTitle: string;
secondTitle: string;
thirdTitle: string;
firstDescription: string;
secondDescription: string;
thirdDescription: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicBanner: DefineComponent<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
validator(value: unknown): boolean;
};
firstTitle: {
type: StringConstructor;
default: null;
};
secondTitle: {
type: StringConstructor;
default: null;
};
thirdTitle: {
type: StringConstructor;
default: null;
};
firstDescription: {
type: StringConstructor;
default: null;
};
secondDescription: {
type: StringConstructor;
default: null;
};
thirdDescription: {
type: StringConstructor;
default: null;
};
subtitle: {
type: StringConstructor;
default: null;
};
rating: {
type: NumberConstructor;
default: number;
};
}>, {}, {}, {
currentComponent(): DefineComponent<ExtractPropTypes<    {
firstTitle: {
type: StringConstructor;
default: null;
};
secondTitle: {
type: StringConstructor;
default: null;
};
thirdTitle: {
type: StringConstructor;
default: null;
};
firstDescription: {
type: StringConstructor;
default: null;
};
secondDescription: {
type: StringConstructor;
default: null;
};
thirdDescription: {
type: StringConstructor;
default: null;
};
subtitle: {
type: StringConstructor;
default: null;
};
rating: {
type: NumberConstructor;
default: number;
};
}>, {}, {
tempRating: null;
baseRating: number;
}, {}, {
emitRatingAction(star: any): void;
starScheme(star: any): "fg-base" | "feedback-yellow";
starOver(star: any): void;
starOut(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
firstTitle: {
type: StringConstructor;
default: null;
};
secondTitle: {
type: StringConstructor;
default: null;
};
thirdTitle: {
type: StringConstructor;
default: null;
};
firstDescription: {
type: StringConstructor;
default: null;
};
secondDescription: {
type: StringConstructor;
default: null;
};
thirdDescription: {
type: StringConstructor;
default: null;
};
subtitle: {
type: StringConstructor;
default: null;
};
rating: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
rating: number;
subtitle: string;
firstTitle: string;
secondTitle: string;
thirdTitle: string;
firstDescription: string;
secondDescription: string;
thirdDescription: string;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;
}, {
emitRatingAction(star: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
validator(value: unknown): boolean;
};
firstTitle: {
type: StringConstructor;
default: null;
};
secondTitle: {
type: StringConstructor;
default: null;
};
thirdTitle: {
type: StringConstructor;
default: null;
};
firstDescription: {
type: StringConstructor;
default: null;
};
secondDescription: {
type: StringConstructor;
default: null;
};
thirdDescription: {
type: StringConstructor;
default: null;
};
subtitle: {
type: StringConstructor;
default: null;
};
rating: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
type: string;
rating: number;
subtitle: string;
firstTitle: string;
secondTitle: string;
thirdTitle: string;
firstDescription: string;
secondDescription: string;
thirdDescription: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicBreadcrumb: DefineComponent<BreadcrumbProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"crumb-click": (crumb: BreadcrumbItem) => any;
}, string, PublicProps, Readonly<BreadcrumbProps> & Readonly<{
"onCrumb-click"?: ((crumb: BreadcrumbItem) => any) | undefined;
}>, {
crumbs: BreadcrumbItem[] | null;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare const unnnicBreadcrumb: DefineComponent<BreadcrumbProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"crumb-click": (crumb: BreadcrumbItem) => any;
}, string, PublicProps, Readonly<BreadcrumbProps> & Readonly<{
"onCrumb-click"?: ((crumb: BreadcrumbItem) => any) | undefined;
}>, {
crumbs: BreadcrumbItem[] | null;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare const UnnnicButton: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    disabled: boolean;
    type: ButtonType;
    text: string;
    size: ButtonSize;
    iconLeft: string;
    iconRight: string;
    float: boolean;
    iconCenter: string;
    iconsFilled: boolean;
    loading: boolean;
    pressed: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLButtonElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
    disabled: boolean;
    type: ButtonType;
    text: string;
    size: ButtonSize;
    iconLeft: string;
    iconRight: string;
    float: boolean;
    iconCenter: string;
    iconsFilled: boolean;
    loading: boolean;
    pressed: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicButton: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    disabled: boolean;
    type: ButtonType;
    text: string;
    size: ButtonSize;
    iconLeft: string;
    iconRight: string;
    float: boolean;
    iconCenter: string;
    iconsFilled: boolean;
    loading: boolean;
    pressed: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLButtonElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
    disabled: boolean;
    type: ButtonType;
    text: string;
    size: ButtonSize;
    iconLeft: string;
    iconRight: string;
    float: boolean;
    iconCenter: string;
    iconsFilled: boolean;
    loading: boolean;
    pressed: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicCallAlert: (props: any) => void;

export declare const unnnicCallAlert: (props: any) => void;

export declare const UnnnicCallModal: (props: any) => void;

export declare const unnnicCallModal: (props: any) => void;

export declare const UnnnicCard: DefineComponent<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
validator(value: unknown): boolean;
};
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
status: {
type: StringConstructor;
default: null;
};
info: {
type: StringConstructor;
default: null;
};
text: {
type: StringConstructor;
default: null;
};
value: {
type: NumberConstructor;
default: null;
};
percent: {
type: NumberConstructor;
default: number;
};
invertedPercentage: {
type: BooleanConstructor;
default: boolean;
};
rating: {
type: NumberConstructor;
default: number;
};
comments: {
type: StringConstructor;
default: null;
};
enabled: {
type: BooleanConstructor;
default: boolean;
};
icon: {
type: StringConstructor;
default: null;
};
iconSrc: {
type: StringConstructor;
default: null;
};
infoPosition: {
type: StringConstructor;
default: string;
};
hasInformationIcon: {
type: BooleanConstructor;
default: boolean;
};
scheme: {
type: StringConstructor;
default: string;
validator(value: unknown): boolean;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
typeAction: {
type: StringConstructor;
default: null;
validator(value: unknown): boolean;
};
buttonAction: {
type: FunctionConstructor;
default: () => void;
};
}>, {}, {}, {
currentTypeIcon(): string | null;
currentComponent(): DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
value: {
type: NumberConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
percent: {
type: NumberConstructor;
default: number;
};
invertedPercentage: {
type: BooleanConstructor;
default: boolean;
};
scheme: {
type: StringConstructor;
default: null;
};
}>, {}, {}, {
color(): "green" | "red";
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
value: {
type: NumberConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
percent: {
type: NumberConstructor;
default: number;
};
invertedPercentage: {
type: BooleanConstructor;
default: boolean;
};
scheme: {
type: StringConstructor;
default: null;
};
}>> & Readonly<{}>, {
value: number;
title: string;
icon: string;
scheme: string;
percent: number;
invertedPercentage: boolean;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
UnnnicAvatarIcon: DefineComponent<AvatarIconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AvatarIconProps> & Readonly<{}>, {
size: AvatarIconSize;
filled: boolean;
icon: string;
scheme: SchemeColor;
enabled: boolean;
opacity: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
}, {}, string, ComponentProvideOptions, true, {}, any> | DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
info: {
type: StringConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
infoPosition: {
type: StringConstructor;
default: string;
};
scheme: {
type: StringConstructor;
default: null;
};
hasInformationIcon: {
type: BooleanConstructor;
default: boolean;
};
enabled: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
info: {
type: StringConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
infoPosition: {
type: StringConstructor;
default: string;
};
scheme: {
type: StringConstructor;
default: null;
};
hasInformationIcon: {
type: BooleanConstructor;
default: boolean;
};
enabled: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
title: string;
info: string;
icon: string;
scheme: string;
enabled: boolean;
infoPosition: string;
hasInformationIcon: boolean;
}, {}, {
ToolTip: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, PublicProps, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, string, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any> | DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
status: {
type: StringConstructor;
default: null;
};
scheme: {
type: StringConstructor;
default: null;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
status: {
type: StringConstructor;
default: null;
};
scheme: {
type: StringConstructor;
default: null;
};
}>> & Readonly<{}>, {
title: string;
icon: string;
scheme: string;
description: string;
status: string;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any> | DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
enabled: {
type: BooleanConstructor;
default: boolean;
};
scheme: {
type: StringConstructor;
default: null;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
enabled: {
type: BooleanConstructor;
default: boolean;
};
scheme: {
type: StringConstructor;
default: null;
};
}>> & Readonly<{}>, {
title: string;
icon: string;
scheme: string;
enabled: boolean;
description: string;
}, {}, {
UnnnicAvatarIcon: DefineComponent<AvatarIconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AvatarIconProps> & Readonly<{}>, {
size: AvatarIconSize;
filled: boolean;
icon: string;
scheme: SchemeColor;
enabled: boolean;
opacity: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
}, {}, string, ComponentProvideOptions, true, {}, any> | DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
title: string;
clickable: boolean;
description: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any> | DefineComponent<ExtractPropTypes<    {
text: {
type: StringConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
text: {
type: StringConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
text: string;
icon: string;
clickable: boolean;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any> | DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
enabled: {
type: BooleanConstructor;
default: boolean;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
enabled: {
type: BooleanConstructor;
default: boolean;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
title: string;
icon: string;
clickable: boolean;
enabled: boolean;
description: string;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any> | DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
comments: {
type: StringConstructor;
default: null;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
iconSrc: {
type: StringConstructor;
default: null;
};
rating: {
type: NumberConstructor;
default: number;
};
typeAction: {
type: StringConstructor;
default: null;
};
}>, {}, {}, {}, {
cardClick(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
comments: {
type: StringConstructor;
default: null;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
iconSrc: {
type: StringConstructor;
default: null;
};
rating: {
type: NumberConstructor;
default: number;
};
typeAction: {
type: StringConstructor;
default: null;
};
}>> & Readonly<{}>, {
title: string;
clickable: boolean;
description: string;
comments: string;
iconSrc: string;
rating: number;
typeAction: string;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;
}, {
openModal(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
validator(value: unknown): boolean;
};
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
status: {
type: StringConstructor;
default: null;
};
info: {
type: StringConstructor;
default: null;
};
text: {
type: StringConstructor;
default: null;
};
value: {
type: NumberConstructor;
default: null;
};
percent: {
type: NumberConstructor;
default: number;
};
invertedPercentage: {
type: BooleanConstructor;
default: boolean;
};
rating: {
type: NumberConstructor;
default: number;
};
comments: {
type: StringConstructor;
default: null;
};
enabled: {
type: BooleanConstructor;
default: boolean;
};
icon: {
type: StringConstructor;
default: null;
};
iconSrc: {
type: StringConstructor;
default: null;
};
infoPosition: {
type: StringConstructor;
default: string;
};
hasInformationIcon: {
type: BooleanConstructor;
default: boolean;
};
scheme: {
type: StringConstructor;
default: string;
validator(value: unknown): boolean;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
typeAction: {
type: StringConstructor;
default: null;
validator(value: unknown): boolean;
};
buttonAction: {
type: FunctionConstructor;
default: () => void;
};
}>> & Readonly<{}>, {
type: string;
value: number;
title: string;
text: string;
info: string;
icon: string;
clickable: boolean;
scheme: string;
enabled: boolean;
description: string;
percent: number;
invertedPercentage: boolean;
infoPosition: string;
hasInformationIcon: boolean;
status: string;
comments: string;
iconSrc: string;
rating: number;
typeAction: string;
buttonAction: Function;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicCard: DefineComponent<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
validator(value: unknown): boolean;
};
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
status: {
type: StringConstructor;
default: null;
};
info: {
type: StringConstructor;
default: null;
};
text: {
type: StringConstructor;
default: null;
};
value: {
type: NumberConstructor;
default: null;
};
percent: {
type: NumberConstructor;
default: number;
};
invertedPercentage: {
type: BooleanConstructor;
default: boolean;
};
rating: {
type: NumberConstructor;
default: number;
};
comments: {
type: StringConstructor;
default: null;
};
enabled: {
type: BooleanConstructor;
default: boolean;
};
icon: {
type: StringConstructor;
default: null;
};
iconSrc: {
type: StringConstructor;
default: null;
};
infoPosition: {
type: StringConstructor;
default: string;
};
hasInformationIcon: {
type: BooleanConstructor;
default: boolean;
};
scheme: {
type: StringConstructor;
default: string;
validator(value: unknown): boolean;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
typeAction: {
type: StringConstructor;
default: null;
validator(value: unknown): boolean;
};
buttonAction: {
type: FunctionConstructor;
default: () => void;
};
}>, {}, {}, {
currentTypeIcon(): string | null;
currentComponent(): DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
value: {
type: NumberConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
percent: {
type: NumberConstructor;
default: number;
};
invertedPercentage: {
type: BooleanConstructor;
default: boolean;
};
scheme: {
type: StringConstructor;
default: null;
};
}>, {}, {}, {
color(): "green" | "red";
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
value: {
type: NumberConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
percent: {
type: NumberConstructor;
default: number;
};
invertedPercentage: {
type: BooleanConstructor;
default: boolean;
};
scheme: {
type: StringConstructor;
default: null;
};
}>> & Readonly<{}>, {
value: number;
title: string;
icon: string;
scheme: string;
percent: number;
invertedPercentage: boolean;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
UnnnicAvatarIcon: DefineComponent<AvatarIconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AvatarIconProps> & Readonly<{}>, {
size: AvatarIconSize;
filled: boolean;
icon: string;
scheme: SchemeColor;
enabled: boolean;
opacity: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
}, {}, string, ComponentProvideOptions, true, {}, any> | DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
info: {
type: StringConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
infoPosition: {
type: StringConstructor;
default: string;
};
scheme: {
type: StringConstructor;
default: null;
};
hasInformationIcon: {
type: BooleanConstructor;
default: boolean;
};
enabled: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
info: {
type: StringConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
infoPosition: {
type: StringConstructor;
default: string;
};
scheme: {
type: StringConstructor;
default: null;
};
hasInformationIcon: {
type: BooleanConstructor;
default: boolean;
};
enabled: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
title: string;
info: string;
icon: string;
scheme: string;
enabled: boolean;
infoPosition: string;
hasInformationIcon: boolean;
}, {}, {
ToolTip: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, PublicProps, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, string, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any> | DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
status: {
type: StringConstructor;
default: null;
};
scheme: {
type: StringConstructor;
default: null;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
status: {
type: StringConstructor;
default: null;
};
scheme: {
type: StringConstructor;
default: null;
};
}>> & Readonly<{}>, {
title: string;
icon: string;
scheme: string;
description: string;
status: string;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any> | DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
enabled: {
type: BooleanConstructor;
default: boolean;
};
scheme: {
type: StringConstructor;
default: null;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
enabled: {
type: BooleanConstructor;
default: boolean;
};
scheme: {
type: StringConstructor;
default: null;
};
}>> & Readonly<{}>, {
title: string;
icon: string;
scheme: string;
enabled: boolean;
description: string;
}, {}, {
UnnnicAvatarIcon: DefineComponent<AvatarIconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AvatarIconProps> & Readonly<{}>, {
size: AvatarIconSize;
filled: boolean;
icon: string;
scheme: SchemeColor;
enabled: boolean;
opacity: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
}, {}, string, ComponentProvideOptions, true, {}, any> | DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
title: string;
clickable: boolean;
description: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any> | DefineComponent<ExtractPropTypes<    {
text: {
type: StringConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
text: {
type: StringConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
text: string;
icon: string;
clickable: boolean;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any> | DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
enabled: {
type: BooleanConstructor;
default: boolean;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
icon: {
type: StringConstructor;
default: null;
};
enabled: {
type: BooleanConstructor;
default: boolean;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
title: string;
icon: string;
clickable: boolean;
enabled: boolean;
description: string;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any> | DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
comments: {
type: StringConstructor;
default: null;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
iconSrc: {
type: StringConstructor;
default: null;
};
rating: {
type: NumberConstructor;
default: number;
};
typeAction: {
type: StringConstructor;
default: null;
};
}>, {}, {}, {}, {
cardClick(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
comments: {
type: StringConstructor;
default: null;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
iconSrc: {
type: StringConstructor;
default: null;
};
rating: {
type: NumberConstructor;
default: number;
};
typeAction: {
type: StringConstructor;
default: null;
};
}>> & Readonly<{}>, {
title: string;
clickable: boolean;
description: string;
comments: string;
iconSrc: string;
rating: number;
typeAction: string;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;
}, {
openModal(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
validator(value: unknown): boolean;
};
title: {
type: StringConstructor;
default: null;
};
description: {
type: StringConstructor;
default: null;
};
status: {
type: StringConstructor;
default: null;
};
info: {
type: StringConstructor;
default: null;
};
text: {
type: StringConstructor;
default: null;
};
value: {
type: NumberConstructor;
default: null;
};
percent: {
type: NumberConstructor;
default: number;
};
invertedPercentage: {
type: BooleanConstructor;
default: boolean;
};
rating: {
type: NumberConstructor;
default: number;
};
comments: {
type: StringConstructor;
default: null;
};
enabled: {
type: BooleanConstructor;
default: boolean;
};
icon: {
type: StringConstructor;
default: null;
};
iconSrc: {
type: StringConstructor;
default: null;
};
infoPosition: {
type: StringConstructor;
default: string;
};
hasInformationIcon: {
type: BooleanConstructor;
default: boolean;
};
scheme: {
type: StringConstructor;
default: string;
validator(value: unknown): boolean;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
typeAction: {
type: StringConstructor;
default: null;
validator(value: unknown): boolean;
};
buttonAction: {
type: FunctionConstructor;
default: () => void;
};
}>> & Readonly<{}>, {
type: string;
value: number;
title: string;
text: string;
info: string;
icon: string;
clickable: boolean;
scheme: string;
enabled: boolean;
description: string;
percent: number;
invertedPercentage: boolean;
infoPosition: string;
hasInformationIcon: boolean;
status: string;
comments: string;
iconSrc: string;
rating: number;
typeAction: string;
buttonAction: Function;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicCardCompany: DefineComponent<ExtractPropTypes<    {
oldVersion: BooleanConstructor;
name: StringConstructor;
description: StringConstructor;
plan: StringConstructor;
actionText: StringConstructor;
}>, {}, {
isOptionsOpen: boolean;
}, {}, {}, {
props: {
locale: {
type: StringConstructor;
};
translations: {
type: ObjectConstructor;
};
};
methods: {
i18n(...args: any[]): any;
};
}, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
oldVersion: BooleanConstructor;
name: StringConstructor;
description: StringConstructor;
plan: StringConstructor;
actionText: StringConstructor;
}>> & Readonly<{}>, {
oldVersion: boolean;
}, {}, {
UnnnicTag: DefineComponent<TagProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: () => any;
close: () => any;
}, string, PublicProps, Readonly<TagProps> & Readonly<{
onClick?: (() => any) | undefined;
onClose?: (() => any) | undefined;
}>, {
disabled: boolean;
type: TagType;
text: string;
size: TagSize;
scheme: string;
leftIcon: string;
hasCloseIcon: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicCardCompany: DefineComponent<ExtractPropTypes<    {
oldVersion: BooleanConstructor;
name: StringConstructor;
description: StringConstructor;
plan: StringConstructor;
actionText: StringConstructor;
}>, {}, {
isOptionsOpen: boolean;
}, {}, {}, {
props: {
locale: {
type: StringConstructor;
};
translations: {
type: ObjectConstructor;
};
};
methods: {
i18n(...args: any[]): any;
};
}, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
oldVersion: BooleanConstructor;
name: StringConstructor;
description: StringConstructor;
plan: StringConstructor;
actionText: StringConstructor;
}>> & Readonly<{}>, {
oldVersion: boolean;
}, {}, {
UnnnicTag: DefineComponent<TagProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: () => any;
close: () => any;
}, string, PublicProps, Readonly<TagProps> & Readonly<{
onClick?: (() => any) | undefined;
onClose?: (() => any) | undefined;
}>, {
disabled: boolean;
type: TagType;
text: string;
size: TagSize;
scheme: string;
leftIcon: string;
hasCloseIcon: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicCardData: DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
};
description: {
type: StringConstructor;
};
score: {
type: StringConstructor;
};
info: {
type: StringConstructor;
};
checked: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
};
description: {
type: StringConstructor;
};
score: {
type: StringConstructor;
};
info: {
type: StringConstructor;
};
checked: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
checked: boolean;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicCardData: DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
};
description: {
type: StringConstructor;
};
score: {
type: StringConstructor;
};
info: {
type: StringConstructor;
};
checked: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
};
description: {
type: StringConstructor;
};
score: {
type: StringConstructor;
};
info: {
type: StringConstructor;
};
checked: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
checked: boolean;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicCardImage: VueComponent;

export declare const unnnicCardImage: VueComponent;

export declare const UnnnicCardInformation: DefineComponent<ExtractPropTypes<    {
name: {
type: StringConstructor;
default: string;
};
subtitle: {
type: StringConstructor;
default: string;
};
description: {
type: StringConstructor;
default: string;
};
descriptionRow: {
type: StringConstructor;
default: string;
};
descriptionRowInfo: {
type: StringConstructor;
default: string;
};
statuses: {
type: ArrayConstructor;
};
}>, {}, {
unnnicFontSize: number;
}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
name: {
type: StringConstructor;
default: string;
};
subtitle: {
type: StringConstructor;
default: string;
};
description: {
type: StringConstructor;
default: string;
};
descriptionRow: {
type: StringConstructor;
default: string;
};
descriptionRowInfo: {
type: StringConstructor;
default: string;
};
statuses: {
type: ArrayConstructor;
};
}>> & Readonly<{}>, {
name: string;
description: string;
subtitle: string;
descriptionRow: string;
descriptionRowInfo: string;
}, {}, {
CardStatusesContainer: DefineComponent<ExtractPropTypes<    {
name: {
type: StringConstructor;
default: string;
};
subtitle: {
type: StringConstructor;
default: string;
};
description: {
type: StringConstructor;
default: string;
};
descriptionRow: {
type: StringConstructor;
default: string;
};
descriptionRowInfo: {
type: StringConstructor;
default: string;
};
statuses: {
type: ArrayConstructor;
};
minStatusWidth: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
name: {
type: StringConstructor;
default: string;
};
subtitle: {
type: StringConstructor;
default: string;
};
description: {
type: StringConstructor;
default: string;
};
descriptionRow: {
type: StringConstructor;
default: string;
};
descriptionRowInfo: {
type: StringConstructor;
default: string;
};
statuses: {
type: ArrayConstructor;
};
minStatusWidth: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
}>> & Readonly<{}>, {
name: string;
description: string;
subtitle: string;
descriptionRow: string;
descriptionRowInfo: string;
minStatusWidth: string | number;
}, {}, {
UnnnicAvatarIcon: DefineComponent<AvatarIconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AvatarIconProps> & Readonly<{}>, {
size: AvatarIconSize;
filled: boolean;
icon: string;
scheme: SchemeColor;
enabled: boolean;
opacity: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
UnnnicToolTip: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, PublicProps, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, string, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicCardInformation: DefineComponent<ExtractPropTypes<    {
name: {
type: StringConstructor;
default: string;
};
subtitle: {
type: StringConstructor;
default: string;
};
description: {
type: StringConstructor;
default: string;
};
descriptionRow: {
type: StringConstructor;
default: string;
};
descriptionRowInfo: {
type: StringConstructor;
default: string;
};
statuses: {
type: ArrayConstructor;
};
}>, {}, {
unnnicFontSize: number;
}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
name: {
type: StringConstructor;
default: string;
};
subtitle: {
type: StringConstructor;
default: string;
};
description: {
type: StringConstructor;
default: string;
};
descriptionRow: {
type: StringConstructor;
default: string;
};
descriptionRowInfo: {
type: StringConstructor;
default: string;
};
statuses: {
type: ArrayConstructor;
};
}>> & Readonly<{}>, {
name: string;
description: string;
subtitle: string;
descriptionRow: string;
descriptionRowInfo: string;
}, {}, {
CardStatusesContainer: DefineComponent<ExtractPropTypes<    {
name: {
type: StringConstructor;
default: string;
};
subtitle: {
type: StringConstructor;
default: string;
};
description: {
type: StringConstructor;
default: string;
};
descriptionRow: {
type: StringConstructor;
default: string;
};
descriptionRowInfo: {
type: StringConstructor;
default: string;
};
statuses: {
type: ArrayConstructor;
};
minStatusWidth: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
name: {
type: StringConstructor;
default: string;
};
subtitle: {
type: StringConstructor;
default: string;
};
description: {
type: StringConstructor;
default: string;
};
descriptionRow: {
type: StringConstructor;
default: string;
};
descriptionRowInfo: {
type: StringConstructor;
default: string;
};
statuses: {
type: ArrayConstructor;
};
minStatusWidth: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
}>> & Readonly<{}>, {
name: string;
description: string;
subtitle: string;
descriptionRow: string;
descriptionRowInfo: string;
minStatusWidth: string | number;
}, {}, {
UnnnicAvatarIcon: DefineComponent<AvatarIconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AvatarIconProps> & Readonly<{}>, {
size: AvatarIconSize;
filled: boolean;
icon: string;
scheme: SchemeColor;
enabled: boolean;
opacity: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
UnnnicToolTip: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, PublicProps, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, string, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicCardNumber: DefineComponent<ExtractPropTypes<    {
description: {
type: StringConstructor;
default: string;
};
number: {
type: StringConstructor;
default: string;
};
fullSize: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
description: {
type: StringConstructor;
default: string;
};
number: {
type: StringConstructor;
default: string;
};
fullSize: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
number: string;
description: string;
fullSize: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicCardNumber: DefineComponent<ExtractPropTypes<    {
description: {
type: StringConstructor;
default: string;
};
number: {
type: StringConstructor;
default: string;
};
fullSize: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
description: {
type: StringConstructor;
default: string;
};
number: {
type: StringConstructor;
default: string;
};
fullSize: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
number: string;
description: string;
fullSize: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicCardProject: VueComponent;

export declare const unnnicCardProject: VueComponent;

export declare const UnnnicChartBar: DefineComponent<ExtractPropTypes<    {
condensed: BooleanConstructor;
groups: ArrayConstructor;
fixedMaxValue: NumberConstructor;
title: StringConstructor;
description: StringConstructor;
updateText: StringConstructor;
previousDisabled: BooleanConstructor;
nextDisabled: BooleanConstructor;
showFooterLegend: BooleanConstructor;
}>, {}, {
colors: string[];
}, {
legends(): any[];
maxValue(): number;
}, {
value(value: any): any;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
condensed: BooleanConstructor;
groups: ArrayConstructor;
fixedMaxValue: NumberConstructor;
title: StringConstructor;
description: StringConstructor;
updateText: StringConstructor;
previousDisabled: BooleanConstructor;
nextDisabled: BooleanConstructor;
showFooterLegend: BooleanConstructor;
}>> & Readonly<{}>, {
condensed: boolean;
previousDisabled: boolean;
nextDisabled: boolean;
showFooterLegend: boolean;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
UnnnicButton: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLButtonElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicToolTip: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, PublicProps, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, string, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicChartBar: DefineComponent<ExtractPropTypes<    {
condensed: BooleanConstructor;
groups: ArrayConstructor;
fixedMaxValue: NumberConstructor;
title: StringConstructor;
description: StringConstructor;
updateText: StringConstructor;
previousDisabled: BooleanConstructor;
nextDisabled: BooleanConstructor;
showFooterLegend: BooleanConstructor;
}>, {}, {
colors: string[];
}, {
legends(): any[];
maxValue(): number;
}, {
value(value: any): any;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
condensed: BooleanConstructor;
groups: ArrayConstructor;
fixedMaxValue: NumberConstructor;
title: StringConstructor;
description: StringConstructor;
updateText: StringConstructor;
previousDisabled: BooleanConstructor;
nextDisabled: BooleanConstructor;
showFooterLegend: BooleanConstructor;
}>> & Readonly<{}>, {
condensed: boolean;
previousDisabled: boolean;
nextDisabled: boolean;
showFooterLegend: boolean;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
UnnnicButton: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLButtonElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicToolTip: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, PublicProps, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, string, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicChartFunnel: VueComponent;

export declare const unnnicChartFunnel: VueComponent;

export declare const UnnnicChartLine: DefineComponent<ExtractPropTypes<    {
condensed: BooleanConstructor;
fixedMaxValue: NumberConstructor;
data: ArrayConstructor;
title: StringConstructor;
}>, {}, {
chartContainerWidthInterval: null;
chartContainerWidth: number;
}, {
maxValue(): number;
svgChart(): string;
}, {
value(value: any): any;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
condensed: BooleanConstructor;
fixedMaxValue: NumberConstructor;
data: ArrayConstructor;
title: StringConstructor;
}>> & Readonly<{}>, {
condensed: boolean;
}, {}, {
UnnnicToolTip: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, PublicProps, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, string, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicChartLine: DefineComponent<ExtractPropTypes<    {
condensed: BooleanConstructor;
fixedMaxValue: NumberConstructor;
data: ArrayConstructor;
title: StringConstructor;
}>, {}, {
chartContainerWidthInterval: null;
chartContainerWidth: number;
}, {
maxValue(): number;
svgChart(): string;
}, {
value(value: any): any;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
condensed: BooleanConstructor;
fixedMaxValue: NumberConstructor;
data: ArrayConstructor;
title: StringConstructor;
}>> & Readonly<{}>, {
condensed: boolean;
}, {}, {
UnnnicToolTip: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, PublicProps, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, string, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicChartMultiLine: DefineComponent<ExtractPropTypes<    {
condensed: BooleanConstructor;
fixedMaxValue: NumberConstructor;
data: ArrayConstructor;
title: StringConstructor;
}>, {}, {
titles: never[];
colors: string[];
}, {
maxValue(): number;
minValue(): number;
lineData(): any;
}, {
value(value: any): any;
findMax(array: any): number;
findMin(array: any): number;
findTotals(array: any): any;
formatValue(value: any): string;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
condensed: BooleanConstructor;
fixedMaxValue: NumberConstructor;
data: ArrayConstructor;
title: StringConstructor;
}>> & Readonly<{}>, {
condensed: boolean;
}, {}, {
Lines: DefineComponent<ExtractPropTypes<    {
fixedMaxValue: NumberConstructor;
fixedMinValue: NumberConstructor;
data: ArrayConstructor;
color: StringConstructor;
}>, {}, {
chartContainerWidth: number;
chartContainerHeight: number;
minValue: number;
}, {
maxValue(): number;
svgChart(): string;
}, {
findMax(array: any): number;
findMin(array: any): number;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
fixedMaxValue: NumberConstructor;
fixedMinValue: NumberConstructor;
data: ArrayConstructor;
color: StringConstructor;
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicChartMultiLine: DefineComponent<ExtractPropTypes<    {
condensed: BooleanConstructor;
fixedMaxValue: NumberConstructor;
data: ArrayConstructor;
title: StringConstructor;
}>, {}, {
titles: never[];
colors: string[];
}, {
maxValue(): number;
minValue(): number;
lineData(): any;
}, {
value(value: any): any;
findMax(array: any): number;
findMin(array: any): number;
findTotals(array: any): any;
formatValue(value: any): string;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
condensed: BooleanConstructor;
fixedMaxValue: NumberConstructor;
data: ArrayConstructor;
title: StringConstructor;
}>> & Readonly<{}>, {
condensed: boolean;
}, {}, {
Lines: DefineComponent<ExtractPropTypes<    {
fixedMaxValue: NumberConstructor;
fixedMinValue: NumberConstructor;
data: ArrayConstructor;
color: StringConstructor;
}>, {}, {
chartContainerWidth: number;
chartContainerHeight: number;
minValue: number;
}, {
maxValue(): number;
svgChart(): string;
}, {
findMax(array: any): number;
findMin(array: any): number;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
fixedMaxValue: NumberConstructor;
fixedMinValue: NumberConstructor;
data: ArrayConstructor;
color: StringConstructor;
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicChartRainbow: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: NumberConstructor;
default: number;
};
description: {
type: StringConstructor;
};
}>, {}, {}, {}, {
updateChartSvg(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: NumberConstructor;
default: number;
};
description: {
type: StringConstructor;
};
}>> & Readonly<{}>, {
modelValue: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicChartRainbow: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: NumberConstructor;
default: number;
};
description: {
type: StringConstructor;
};
}>, {}, {}, {}, {
updateChartSvg(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: NumberConstructor;
default: number;
};
description: {
type: StringConstructor;
};
}>> & Readonly<{}>, {
modelValue: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicChatsUserAvatar: DefineComponent<ExtractPropTypes<    {
active: {
type: BooleanConstructor;
default: boolean;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
size: {
type: StringConstructor;
default: string;
validator: (value: unknown) => boolean;
};
username: {
type: StringConstructor;
default: string;
};
photoUrl: {
type: StringConstructor;
default: string;
};
scheme: {
type: StringConstructor;
default: string;
};
textColor: {
type: StringConstructor;
default: string;
};
}>, {}, {}, {
getUsernameFirstCharacter(): string;
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "click"[], "click", PublicProps, Readonly<ExtractPropTypes<    {
active: {
type: BooleanConstructor;
default: boolean;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
size: {
type: StringConstructor;
default: string;
validator: (value: unknown) => boolean;
};
username: {
type: StringConstructor;
default: string;
};
photoUrl: {
type: StringConstructor;
default: string;
};
scheme: {
type: StringConstructor;
default: string;
};
textColor: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{
onClick?: ((...args: any[]) => any) | undefined;
}>, {
disabled: boolean;
size: string;
clickable: boolean;
scheme: string;
active: boolean;
username: string;
photoUrl: string;
textColor: string;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicChatsUserAvatar: DefineComponent<ExtractPropTypes<    {
active: {
type: BooleanConstructor;
default: boolean;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
size: {
type: StringConstructor;
default: string;
validator: (value: unknown) => boolean;
};
username: {
type: StringConstructor;
default: string;
};
photoUrl: {
type: StringConstructor;
default: string;
};
scheme: {
type: StringConstructor;
default: string;
};
textColor: {
type: StringConstructor;
default: string;
};
}>, {}, {}, {
getUsernameFirstCharacter(): string;
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "click"[], "click", PublicProps, Readonly<ExtractPropTypes<    {
active: {
type: BooleanConstructor;
default: boolean;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
size: {
type: StringConstructor;
default: string;
validator: (value: unknown) => boolean;
};
username: {
type: StringConstructor;
default: string;
};
photoUrl: {
type: StringConstructor;
default: string;
};
scheme: {
type: StringConstructor;
default: string;
};
textColor: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{
onClick?: ((...args: any[]) => any) | undefined;
}>, {
disabled: boolean;
size: string;
clickable: boolean;
scheme: string;
active: boolean;
username: string;
photoUrl: string;
textColor: string;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicCheckbox: DefineComponent<CheckboxProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
change: (value: boolean) => any;
"update:model-value": (value: boolean) => any;
}, string, PublicProps, Readonly<CheckboxProps> & Readonly<{
onChange?: ((value: boolean) => any) | undefined;
"onUpdate:model-value"?: ((value: boolean) => any) | undefined;
}>, {
disabled: boolean;
label: string;
modelValue: CheckboxValue;
helper: string;
textRight: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;

export declare const unnnicCheckbox: DefineComponent<CheckboxProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
change: (value: boolean) => any;
"update:model-value": (value: boolean) => any;
}, string, PublicProps, Readonly<CheckboxProps> & Readonly<{
onChange?: ((value: boolean) => any) | undefined;
"onUpdate:model-value"?: ((value: boolean) => any) | undefined;
}>, {
disabled: boolean;
label: string;
modelValue: CheckboxValue;
helper: string;
textRight: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;

export declare const UnnnicCheckboxGroup: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<CheckboxGroupProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    label: string;
    helper: string;
    state: "horizontal" | "vertical";
    labelTooltip: TooltipProps;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<CheckboxGroupProps> & Readonly<{}>, {}, {}, {}, {}, {
    label: string;
    helper: string;
    state: "horizontal" | "vertical";
    labelTooltip: TooltipProps;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<CheckboxGroupProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
label: string;
helper: string;
state: "horizontal" | "vertical";
labelTooltip: TooltipProps;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicCheckboxGroup: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<CheckboxGroupProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    label: string;
    helper: string;
    state: "horizontal" | "vertical";
    labelTooltip: TooltipProps;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<CheckboxGroupProps> & Readonly<{}>, {}, {}, {}, {}, {
    label: string;
    helper: string;
    state: "horizontal" | "vertical";
    labelTooltip: TooltipProps;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<CheckboxGroupProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
label: string;
helper: string;
state: "horizontal" | "vertical";
labelTooltip: TooltipProps;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicChip: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ChipProps> & Readonly<{
    onClick?: ((event: Event) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    click: (event: Event) => any;
    }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ChipProps> & Readonly<{
    onClick?: ((event: Event) => any) | undefined;
    }>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ChipProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        right?(_: {}): any;
    };
});

export declare const unnnicChip: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ChipProps> & Readonly<{
    onClick?: ((event: Event) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    click: (event: Event) => any;
    }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ChipProps> & Readonly<{
    onClick?: ((event: Event) => any) | undefined;
    }>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ChipProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        right?(_: {}): any;
    };
});

export declare const UnnnicCollapse: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
    $emit: (event: "change" | "update:modelValue", ...args: any[]) => void;
    size: string;
    modelValue: boolean;
    active: boolean;
    borderBottom: boolean;
    unspacedIcon: boolean;
    title?: string | undefined;
    $props: {
    readonly size?: string | undefined;
    readonly modelValue?: boolean | undefined;
    readonly active?: boolean | undefined;
    readonly borderBottom?: boolean | undefined;
    readonly unspacedIcon?: boolean | undefined;
    readonly title?: string | undefined;
    };
    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLDivElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{}> & Readonly<{}>, {
    $emit: (event: "change" | "update:modelValue", ...args: any[]) => void;
    size: string;
    modelValue: boolean;
    active: boolean;
    borderBottom: boolean;
    unspacedIcon: boolean;
    title?: string | undefined;
    $props: {
    readonly size?: string | undefined;
    readonly modelValue?: boolean | undefined;
    readonly active?: boolean | undefined;
    readonly borderBottom?: boolean | undefined;
    readonly unspacedIcon?: boolean | undefined;
    readonly title?: string | undefined;
    };
    }, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
$emit: (event: "change" | "update:modelValue", ...args: any[]) => void;
size: string;
modelValue: boolean;
active: boolean;
borderBottom: boolean;
unspacedIcon: boolean;
title?: string | undefined;
$props: {
readonly size?: string | undefined;
readonly modelValue?: boolean | undefined;
readonly active?: boolean | undefined;
readonly borderBottom?: boolean | undefined;
readonly unspacedIcon?: boolean | undefined;
readonly title?: string | undefined;
};
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        header?(_: {}): any;
        default?(_: {}): any;
    };
});

export declare const unnnicCollapse: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
    $emit: (event: "change" | "update:modelValue", ...args: any[]) => void;
    size: string;
    modelValue: boolean;
    active: boolean;
    borderBottom: boolean;
    unspacedIcon: boolean;
    title?: string | undefined;
    $props: {
    readonly size?: string | undefined;
    readonly modelValue?: boolean | undefined;
    readonly active?: boolean | undefined;
    readonly borderBottom?: boolean | undefined;
    readonly unspacedIcon?: boolean | undefined;
    readonly title?: string | undefined;
    };
    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLDivElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{}> & Readonly<{}>, {
    $emit: (event: "change" | "update:modelValue", ...args: any[]) => void;
    size: string;
    modelValue: boolean;
    active: boolean;
    borderBottom: boolean;
    unspacedIcon: boolean;
    title?: string | undefined;
    $props: {
    readonly size?: string | undefined;
    readonly modelValue?: boolean | undefined;
    readonly active?: boolean | undefined;
    readonly borderBottom?: boolean | undefined;
    readonly unspacedIcon?: boolean | undefined;
    readonly title?: string | undefined;
    };
    }, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
$emit: (event: "change" | "update:modelValue", ...args: any[]) => void;
size: string;
modelValue: boolean;
active: boolean;
borderBottom: boolean;
unspacedIcon: boolean;
title?: string | undefined;
$props: {
readonly size?: string | undefined;
readonly modelValue?: boolean | undefined;
readonly active?: boolean | undefined;
readonly borderBottom?: boolean | undefined;
readonly unspacedIcon?: boolean | undefined;
readonly title?: string | undefined;
};
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        header?(_: {}): any;
        default?(_: {}): any;
    };
});

export declare const UnnnicComment: DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
time: {
type: StringConstructor;
default: null;
};
text: {
type: StringConstructor;
default: null;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
time: {
type: StringConstructor;
default: null;
};
text: {
type: StringConstructor;
default: null;
};
}>> & Readonly<{}>, {
time: string;
title: string;
text: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicComment: DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
time: {
type: StringConstructor;
default: null;
};
text: {
type: StringConstructor;
default: null;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
time: {
type: StringConstructor;
default: null;
};
text: {
type: StringConstructor;
default: null;
};
}>> & Readonly<{}>, {
time: string;
title: string;
text: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicDataArea: DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
text: {
type: StringConstructor;
default: null;
};
enableHover: {
type: BooleanConstructor;
default: boolean;
};
hoverText: {
type: StringConstructor;
default: string;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
text: {
type: StringConstructor;
default: null;
};
enableHover: {
type: BooleanConstructor;
default: boolean;
};
hoverText: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
title: string;
text: string;
enableHover: boolean;
hoverText: string;
}, {}, {
ToolTip: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, PublicProps, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, string, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicDataArea: DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
text: {
type: StringConstructor;
default: null;
};
enableHover: {
type: BooleanConstructor;
default: boolean;
};
hoverText: {
type: StringConstructor;
default: string;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: null;
};
text: {
type: StringConstructor;
default: null;
};
enableHover: {
type: BooleanConstructor;
default: boolean;
};
hoverText: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
title: string;
text: string;
enableHover: boolean;
hoverText: string;
}, {}, {
ToolTip: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, PublicProps, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, string, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicDataTable: VueComponent;

export declare const unnnicDataTable: VueComponent;

export declare const UnnnicDateFilter: DefineComponent<ExtractPropTypes<    {
size: {
type: StringConstructor;
default: string;
};
dateFormat: {
type: StringConstructor;
default: string;
};
dateSeparator: {
type: StringConstructor;
default: string;
};
startDate: {
type: DateConstructor;
default: null;
};
endDate: {
type: DateConstructor;
default: null;
};
placeholder: {
type: StringConstructor;
default: string;
};
}>, {}, {}, {
dateRange(): string;
fullMask(): string;
maskedDateFormat(): string;
}, {
emitFilter(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
size: {
type: StringConstructor;
default: string;
};
dateFormat: {
type: StringConstructor;
default: string;
};
dateSeparator: {
type: StringConstructor;
default: string;
};
startDate: {
type: DateConstructor;
default: null;
};
endDate: {
type: DateConstructor;
default: null;
};
placeholder: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
placeholder: string;
size: string;
startDate: Date;
endDate: Date;
dateFormat: string;
dateSeparator: string;
}, {}, {
UnnnicInput: DefineComponent<InputProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
clear: () => any;
"update:modelValue": (value: string) => any;
}, string, PublicProps, Readonly<InputProps> & Readonly<{
onClear?: (() => any) | undefined;
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
}>, {
disabled: boolean;
focus: boolean;
type: InputVariant;
placeholder: string;
label: string;
mask: string | string[];
size: InputSize | string;
tooltip: TooltipProps;
message: string;
modelValue: string;
nativeType: string;
maxlength: number | null;
readonly: boolean;
useFocusProp: boolean;
iconLeft: string;
iconRight: string;
iconLeftClickable: boolean;
iconRightClickable: boolean;
allowTogglePassword: boolean;
showClear: boolean;
errors: string | string[];
hasCloudyColor: boolean;
showMaxlengthCounter: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicDateFilter: DefineComponent<ExtractPropTypes<    {
size: {
type: StringConstructor;
default: string;
};
dateFormat: {
type: StringConstructor;
default: string;
};
dateSeparator: {
type: StringConstructor;
default: string;
};
startDate: {
type: DateConstructor;
default: null;
};
endDate: {
type: DateConstructor;
default: null;
};
placeholder: {
type: StringConstructor;
default: string;
};
}>, {}, {}, {
dateRange(): string;
fullMask(): string;
maskedDateFormat(): string;
}, {
emitFilter(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
size: {
type: StringConstructor;
default: string;
};
dateFormat: {
type: StringConstructor;
default: string;
};
dateSeparator: {
type: StringConstructor;
default: string;
};
startDate: {
type: DateConstructor;
default: null;
};
endDate: {
type: DateConstructor;
default: null;
};
placeholder: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
placeholder: string;
size: string;
startDate: Date;
endDate: Date;
dateFormat: string;
dateSeparator: string;
}, {}, {
UnnnicInput: DefineComponent<InputProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
clear: () => any;
"update:modelValue": (value: string) => any;
}, string, PublicProps, Readonly<InputProps> & Readonly<{
onClear?: (() => any) | undefined;
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
}>, {
disabled: boolean;
focus: boolean;
type: InputVariant;
placeholder: string;
label: string;
mask: string | string[];
size: InputSize | string;
tooltip: TooltipProps;
message: string;
modelValue: string;
nativeType: string;
maxlength: number | null;
readonly: boolean;
useFocusProp: boolean;
iconLeft: string;
iconRight: string;
iconLeftClickable: boolean;
iconRightClickable: boolean;
allowTogglePassword: boolean;
showClear: boolean;
errors: string | string[];
hasCloudyColor: boolean;
showMaxlengthCounter: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicDatePicker: DefineComponent<DatePickerProps, {
i18n: (key: string, ...args: (string | number | Record<string, string>)[]) => string | undefined;
startDate: Ref<string, string>;
endDate: Ref<string, string>;
optionSelected: Ref<string, string>;
referenceDate: Ref<string, string>;
autoSelect: (method: string) => void;
dateToString: (date: Date) => string;
getStartAndEndDateByPeriod: (period: string) => {
startDate: string | undefined;
endDate: string | undefined;
};
getDatesOfTheMonth: (reference: string) => DateCell[];
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
change: (value: {
startDate: string;
endDate: string;
}) => any;
submit: (value: {
startDate: string;
endDate: string;
}) => any;
"update:equivalentOption": (equivalentOption: string) => any;
}, string, PublicProps, Readonly<DatePickerProps> & Readonly<{
onChange?: ((value: {
startDate: string;
endDate: string;
}) => any) | undefined;
onSubmit?: ((value: {
startDate: string;
endDate: string;
}) => any) | undefined;
"onUpdate:equivalentOption"?: ((equivalentOption: string) => any) | undefined;
}>, {
type: "day" | "month" | "year";
size: "small" | "large";
locale: string;
initialStartDate: string;
initialEndDate: string;
minDate: string;
maxDate: string;
periodBaseDate: string;
equivalentOption: string;
clearLabel: string;
actionLabel: string;
months: string[];
days: string[];
options: PeriodOption[];
disableClear: boolean;
hideOptions: boolean;
translations: DatePickerTranslations;
variant: "card" | "popover";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare const unnnicDatePicker: DefineComponent<DatePickerProps, {
i18n: (key: string, ...args: (string | number | Record<string, string>)[]) => string | undefined;
startDate: Ref<string, string>;
endDate: Ref<string, string>;
optionSelected: Ref<string, string>;
referenceDate: Ref<string, string>;
autoSelect: (method: string) => void;
dateToString: (date: Date) => string;
getStartAndEndDateByPeriod: (period: string) => {
startDate: string | undefined;
endDate: string | undefined;
};
getDatesOfTheMonth: (reference: string) => DateCell[];
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
change: (value: {
startDate: string;
endDate: string;
}) => any;
submit: (value: {
startDate: string;
endDate: string;
}) => any;
"update:equivalentOption": (equivalentOption: string) => any;
}, string, PublicProps, Readonly<DatePickerProps> & Readonly<{
onChange?: ((value: {
startDate: string;
endDate: string;
}) => any) | undefined;
onSubmit?: ((value: {
startDate: string;
endDate: string;
}) => any) | undefined;
"onUpdate:equivalentOption"?: ((equivalentOption: string) => any) | undefined;
}>, {
type: "day" | "month" | "year";
size: "small" | "large";
locale: string;
initialStartDate: string;
initialEndDate: string;
minDate: string;
maxDate: string;
periodBaseDate: string;
equivalentOption: string;
clearLabel: string;
actionLabel: string;
months: string[];
days: string[];
options: PeriodOption[];
disableClear: boolean;
hideOptions: boolean;
translations: DatePickerTranslations;
variant: "card" | "popover";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare const UnnnicDialog: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogRootProps & {
    lazyMount?: boolean;
    unmountDelay?: number;
    }> & Readonly<{
    "onUpdate:open"?: ((value: boolean) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:open": (value: boolean) => any;
    }, PublicProps, {
    lazyMount: boolean;
    unmountDelay: number;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<DialogRootProps & {
    lazyMount?: boolean;
    unmountDelay?: number;
    }> & Readonly<{
    "onUpdate:open"?: ((value: boolean) => any) | undefined;
    }>, {}, {}, {}, {}, {
    lazyMount: boolean;
    unmountDelay: number;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogRootProps & {
lazyMount?: boolean;
unmountDelay?: number;
}> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
}, string, {
lazyMount: boolean;
unmountDelay: number;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicDialog: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogRootProps & {
    lazyMount?: boolean;
    unmountDelay?: number;
    }> & Readonly<{
    "onUpdate:open"?: ((value: boolean) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:open": (value: boolean) => any;
    }, PublicProps, {
    lazyMount: boolean;
    unmountDelay: number;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<DialogRootProps & {
    lazyMount?: boolean;
    unmountDelay?: number;
    }> & Readonly<{
    "onUpdate:open"?: ((value: boolean) => any) | undefined;
    }>, {}, {}, {}, {}, {
    lazyMount: boolean;
    unmountDelay: number;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogRootProps & {
lazyMount?: boolean;
unmountDelay?: number;
}> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
}, string, {
lazyMount: boolean;
unmountDelay: number;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicDialogClose: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogCloseProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    asChild: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<DialogCloseProps> & Readonly<{}>, {}, {}, {}, {}, {
    asChild: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogCloseProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
asChild: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicDialogClose: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogCloseProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    asChild: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<DialogCloseProps> & Readonly<{}>, {}, {}, {}, {}, {
    asChild: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogCloseProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
asChild: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicDialogContent: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogContentProps & {
    parentClass?: HTMLAttributes["class"];
    class?: HTMLAttributes["class"];
    size?: "small" | "medium" | "large";
    }> & Readonly<{
    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
    onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
    onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
    onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
    onOpenAutoFocus?: ((event: Event) => any) | undefined;
    onCloseAutoFocus?: ((event: Event) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    escapeKeyDown: (event: KeyboardEvent) => any;
    pointerDownOutside: (event: PointerDownOutsideEvent) => any;
    focusOutside: (event: FocusOutsideEvent) => any;
    interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
    openAutoFocus: (event: Event) => any;
    closeAutoFocus: (event: Event) => any;
    }, PublicProps, {
    class: HTMLAttributes["class"];
    size: "small" | "medium" | "large";
    parentClass: HTMLAttributes["class"];
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<DialogContentProps & {
    parentClass?: HTMLAttributes["class"];
    class?: HTMLAttributes["class"];
    size?: "small" | "medium" | "large";
    }> & Readonly<{
    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
    onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
    onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
    onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
    onOpenAutoFocus?: ((event: Event) => any) | undefined;
    onCloseAutoFocus?: ((event: Event) => any) | undefined;
    }>, {}, {}, {}, {}, {
    class: HTMLAttributes["class"];
    size: "small" | "medium" | "large";
    parentClass: HTMLAttributes["class"];
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogContentProps & {
parentClass?: HTMLAttributes["class"];
class?: HTMLAttributes["class"];
size?: "small" | "medium" | "large";
}> & Readonly<{
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onOpenAutoFocus?: ((event: Event) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
escapeKeyDown: (event: KeyboardEvent) => any;
pointerDownOutside: (event: PointerDownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
openAutoFocus: (event: Event) => any;
closeAutoFocus: (event: Event) => any;
}, string, {
class: HTMLAttributes["class"];
size: "small" | "medium" | "large";
parentClass: HTMLAttributes["class"];
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicDialogContent: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogContentProps & {
    parentClass?: HTMLAttributes["class"];
    class?: HTMLAttributes["class"];
    size?: "small" | "medium" | "large";
    }> & Readonly<{
    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
    onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
    onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
    onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
    onOpenAutoFocus?: ((event: Event) => any) | undefined;
    onCloseAutoFocus?: ((event: Event) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    escapeKeyDown: (event: KeyboardEvent) => any;
    pointerDownOutside: (event: PointerDownOutsideEvent) => any;
    focusOutside: (event: FocusOutsideEvent) => any;
    interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
    openAutoFocus: (event: Event) => any;
    closeAutoFocus: (event: Event) => any;
    }, PublicProps, {
    class: HTMLAttributes["class"];
    size: "small" | "medium" | "large";
    parentClass: HTMLAttributes["class"];
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<DialogContentProps & {
    parentClass?: HTMLAttributes["class"];
    class?: HTMLAttributes["class"];
    size?: "small" | "medium" | "large";
    }> & Readonly<{
    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
    onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
    onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
    onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
    onOpenAutoFocus?: ((event: Event) => any) | undefined;
    onCloseAutoFocus?: ((event: Event) => any) | undefined;
    }>, {}, {}, {}, {}, {
    class: HTMLAttributes["class"];
    size: "small" | "medium" | "large";
    parentClass: HTMLAttributes["class"];
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogContentProps & {
parentClass?: HTMLAttributes["class"];
class?: HTMLAttributes["class"];
size?: "small" | "medium" | "large";
}> & Readonly<{
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onOpenAutoFocus?: ((event: Event) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
escapeKeyDown: (event: KeyboardEvent) => any;
pointerDownOutside: (event: PointerDownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
openAutoFocus: (event: Event) => any;
closeAutoFocus: (event: Event) => any;
}, string, {
class: HTMLAttributes["class"];
size: "small" | "medium" | "large";
parentClass: HTMLAttributes["class"];
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicDialogFooter: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
    class?: HTMLAttributes["class"];
    divider?: boolean;
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    divider: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{
    class?: HTMLAttributes["class"];
    divider?: boolean;
    }> & Readonly<{}>, {}, {}, {}, {}, {
    divider: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
divider?: boolean;
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
divider: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicDialogFooter: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
    class?: HTMLAttributes["class"];
    divider?: boolean;
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    divider: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{
    class?: HTMLAttributes["class"];
    divider?: boolean;
    }> & Readonly<{}>, {}, {}, {}, {}, {
    divider: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
divider?: boolean;
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
divider: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicDialogHeader: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
    class?: HTMLAttributes["class"];
    divider?: boolean;
    type?: "default" | "success" | "warning" | "attention";
    closeButton?: boolean;
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    type: "default" | "success" | "warning" | "attention";
    divider: boolean;
    closeButton: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{
    class?: HTMLAttributes["class"];
    divider?: boolean;
    type?: "default" | "success" | "warning" | "attention";
    closeButton?: boolean;
    }> & Readonly<{}>, {}, {}, {}, {}, {
    type: "default" | "success" | "warning" | "attention";
    divider: boolean;
    closeButton: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
divider?: boolean;
type?: "default" | "success" | "warning" | "attention";
closeButton?: boolean;
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
type: "default" | "success" | "warning" | "attention";
divider: boolean;
closeButton: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicDialogHeader: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
    class?: HTMLAttributes["class"];
    divider?: boolean;
    type?: "default" | "success" | "warning" | "attention";
    closeButton?: boolean;
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    type: "default" | "success" | "warning" | "attention";
    divider: boolean;
    closeButton: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{
    class?: HTMLAttributes["class"];
    divider?: boolean;
    type?: "default" | "success" | "warning" | "attention";
    closeButton?: boolean;
    }> & Readonly<{}>, {}, {}, {}, {}, {
    type: "default" | "success" | "warning" | "attention";
    divider: boolean;
    closeButton: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
divider?: boolean;
type?: "default" | "success" | "warning" | "attention";
closeButton?: boolean;
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
type: "default" | "success" | "warning" | "attention";
divider: boolean;
closeButton: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicDialogTitle: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogTitleProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<DialogTitleProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogTitleProps & {
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicDialogTitle: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogTitleProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<DialogTitleProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogTitleProps & {
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicDialogTrigger: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogTriggerProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<DialogTriggerProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogTriggerProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicDialogTrigger: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogTriggerProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<DialogTriggerProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogTriggerProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicDisclaimer: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DisclaimerProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    type: DisclaimerType;
    title: string;
    icon: string;
    description: string;
    iconColor: SchemeColor;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<DisclaimerProps> & Readonly<{}>, {}, {}, {}, {}, {
    type: DisclaimerType;
    title: string;
    icon: string;
    description: string;
    iconColor: SchemeColor;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<DisclaimerProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
type: DisclaimerType;
title: string;
icon: string;
description: string;
iconColor: SchemeColor;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        icon?(_: {}): any;
        description?(_: {}): any;
    };
});

export declare const unnnicDisclaimer: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DisclaimerProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    type: DisclaimerType;
    title: string;
    icon: string;
    description: string;
    iconColor: SchemeColor;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<DisclaimerProps> & Readonly<{}>, {}, {}, {}, {}, {
    type: DisclaimerType;
    title: string;
    icon: string;
    description: string;
    iconColor: SchemeColor;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<DisclaimerProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
type: DisclaimerType;
title: string;
icon: string;
description: string;
iconColor: SchemeColor;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        icon?(_: {}): any;
        description?(_: {}): any;
    };
});

export declare const UnnnicDrawer: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
    $emit: (event: "close" | "back" | "primaryButtonClick" | "secondaryButtonClick", ...args: any[]) => void;
    title: string;
    class: string;
    size: string;
    modelValue: boolean;
    description: string;
    closeIcon: string;
    lazyMount: boolean;
    unmountDelay: number;
    disabledPrimaryButton: boolean;
    disabledSecondaryButton: boolean;
    loadingPrimaryButton: boolean;
    loadingSecondaryButton: boolean;
    primaryButtonText: string;
    primaryButtonType: string;
    secondaryButtonText: string;
    withoutOverlay: boolean;
    distinctCloseBack: boolean;
    $props: {
    readonly title?: string | undefined;
    readonly class?: string | undefined;
    readonly size?: string | undefined;
    readonly modelValue?: boolean | undefined;
    readonly description?: string | undefined;
    readonly closeIcon?: string | undefined;
    readonly lazyMount?: boolean | undefined;
    readonly unmountDelay?: number | undefined;
    readonly disabledPrimaryButton?: boolean | undefined;
    readonly disabledSecondaryButton?: boolean | undefined;
    readonly loadingPrimaryButton?: boolean | undefined;
    readonly loadingSecondaryButton?: boolean | undefined;
    readonly primaryButtonText?: string | undefined;
    readonly primaryButtonType?: string | undefined;
    readonly secondaryButtonText?: string | undefined;
    readonly withoutOverlay?: boolean | undefined;
    readonly distinctCloseBack?: boolean | undefined;
    };
    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{}> & Readonly<{}>, {
    $emit: (event: "close" | "back" | "primaryButtonClick" | "secondaryButtonClick", ...args: any[]) => void;
    title: string;
    class: string;
    size: string;
    modelValue: boolean;
    description: string;
    closeIcon: string;
    lazyMount: boolean;
    unmountDelay: number;
    disabledPrimaryButton: boolean;
    disabledSecondaryButton: boolean;
    loadingPrimaryButton: boolean;
    loadingSecondaryButton: boolean;
    primaryButtonText: string;
    primaryButtonType: string;
    secondaryButtonText: string;
    withoutOverlay: boolean;
    distinctCloseBack: boolean;
    $props: {
    readonly title?: string | undefined;
    readonly class?: string | undefined;
    readonly size?: string | undefined;
    readonly modelValue?: boolean | undefined;
    readonly description?: string | undefined;
    readonly closeIcon?: string | undefined;
    readonly lazyMount?: boolean | undefined;
    readonly unmountDelay?: number | undefined;
    readonly disabledPrimaryButton?: boolean | undefined;
    readonly disabledSecondaryButton?: boolean | undefined;
    readonly loadingPrimaryButton?: boolean | undefined;
    readonly loadingSecondaryButton?: boolean | undefined;
    readonly primaryButtonText?: string | undefined;
    readonly primaryButtonType?: string | undefined;
    readonly secondaryButtonText?: string | undefined;
    readonly withoutOverlay?: boolean | undefined;
    readonly distinctCloseBack?: boolean | undefined;
    };
    }, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
$emit: (event: "close" | "back" | "primaryButtonClick" | "secondaryButtonClick", ...args: any[]) => void;
title: string;
class: string;
size: string;
modelValue: boolean;
description: string;
closeIcon: string;
lazyMount: boolean;
unmountDelay: number;
disabledPrimaryButton: boolean;
disabledSecondaryButton: boolean;
loadingPrimaryButton: boolean;
loadingSecondaryButton: boolean;
primaryButtonText: string;
primaryButtonType: string;
secondaryButtonText: string;
withoutOverlay: boolean;
distinctCloseBack: boolean;
$props: {
readonly title?: string | undefined;
readonly class?: string | undefined;
readonly size?: string | undefined;
readonly modelValue?: boolean | undefined;
readonly description?: string | undefined;
readonly closeIcon?: string | undefined;
readonly lazyMount?: boolean | undefined;
readonly unmountDelay?: number | undefined;
readonly disabledPrimaryButton?: boolean | undefined;
readonly disabledSecondaryButton?: boolean | undefined;
readonly loadingPrimaryButton?: boolean | undefined;
readonly loadingSecondaryButton?: boolean | undefined;
readonly primaryButtonText?: string | undefined;
readonly primaryButtonType?: string | undefined;
readonly secondaryButtonText?: string | undefined;
readonly withoutOverlay?: boolean | undefined;
readonly distinctCloseBack?: boolean | undefined;
};
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        title?(_: {}): any;
        content?(_: {}): any;
    };
});

export declare const unnnicDrawer: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
    $emit: (event: "close" | "back" | "primaryButtonClick" | "secondaryButtonClick", ...args: any[]) => void;
    title: string;
    class: string;
    size: string;
    modelValue: boolean;
    description: string;
    closeIcon: string;
    lazyMount: boolean;
    unmountDelay: number;
    disabledPrimaryButton: boolean;
    disabledSecondaryButton: boolean;
    loadingPrimaryButton: boolean;
    loadingSecondaryButton: boolean;
    primaryButtonText: string;
    primaryButtonType: string;
    secondaryButtonText: string;
    withoutOverlay: boolean;
    distinctCloseBack: boolean;
    $props: {
    readonly title?: string | undefined;
    readonly class?: string | undefined;
    readonly size?: string | undefined;
    readonly modelValue?: boolean | undefined;
    readonly description?: string | undefined;
    readonly closeIcon?: string | undefined;
    readonly lazyMount?: boolean | undefined;
    readonly unmountDelay?: number | undefined;
    readonly disabledPrimaryButton?: boolean | undefined;
    readonly disabledSecondaryButton?: boolean | undefined;
    readonly loadingPrimaryButton?: boolean | undefined;
    readonly loadingSecondaryButton?: boolean | undefined;
    readonly primaryButtonText?: string | undefined;
    readonly primaryButtonType?: string | undefined;
    readonly secondaryButtonText?: string | undefined;
    readonly withoutOverlay?: boolean | undefined;
    readonly distinctCloseBack?: boolean | undefined;
    };
    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{}> & Readonly<{}>, {
    $emit: (event: "close" | "back" | "primaryButtonClick" | "secondaryButtonClick", ...args: any[]) => void;
    title: string;
    class: string;
    size: string;
    modelValue: boolean;
    description: string;
    closeIcon: string;
    lazyMount: boolean;
    unmountDelay: number;
    disabledPrimaryButton: boolean;
    disabledSecondaryButton: boolean;
    loadingPrimaryButton: boolean;
    loadingSecondaryButton: boolean;
    primaryButtonText: string;
    primaryButtonType: string;
    secondaryButtonText: string;
    withoutOverlay: boolean;
    distinctCloseBack: boolean;
    $props: {
    readonly title?: string | undefined;
    readonly class?: string | undefined;
    readonly size?: string | undefined;
    readonly modelValue?: boolean | undefined;
    readonly description?: string | undefined;
    readonly closeIcon?: string | undefined;
    readonly lazyMount?: boolean | undefined;
    readonly unmountDelay?: number | undefined;
    readonly disabledPrimaryButton?: boolean | undefined;
    readonly disabledSecondaryButton?: boolean | undefined;
    readonly loadingPrimaryButton?: boolean | undefined;
    readonly loadingSecondaryButton?: boolean | undefined;
    readonly primaryButtonText?: string | undefined;
    readonly primaryButtonType?: string | undefined;
    readonly secondaryButtonText?: string | undefined;
    readonly withoutOverlay?: boolean | undefined;
    readonly distinctCloseBack?: boolean | undefined;
    };
    }, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
$emit: (event: "close" | "back" | "primaryButtonClick" | "secondaryButtonClick", ...args: any[]) => void;
title: string;
class: string;
size: string;
modelValue: boolean;
description: string;
closeIcon: string;
lazyMount: boolean;
unmountDelay: number;
disabledPrimaryButton: boolean;
disabledSecondaryButton: boolean;
loadingPrimaryButton: boolean;
loadingSecondaryButton: boolean;
primaryButtonText: string;
primaryButtonType: string;
secondaryButtonText: string;
withoutOverlay: boolean;
distinctCloseBack: boolean;
$props: {
readonly title?: string | undefined;
readonly class?: string | undefined;
readonly size?: string | undefined;
readonly modelValue?: boolean | undefined;
readonly description?: string | undefined;
readonly closeIcon?: string | undefined;
readonly lazyMount?: boolean | undefined;
readonly unmountDelay?: number | undefined;
readonly disabledPrimaryButton?: boolean | undefined;
readonly disabledSecondaryButton?: boolean | undefined;
readonly loadingPrimaryButton?: boolean | undefined;
readonly loadingSecondaryButton?: boolean | undefined;
readonly primaryButtonText?: string | undefined;
readonly primaryButtonType?: string | undefined;
readonly secondaryButtonText?: string | undefined;
readonly withoutOverlay?: boolean | undefined;
readonly distinctCloseBack?: boolean | undefined;
};
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        title?(_: {}): any;
        content?(_: {}): any;
    };
});

export declare const UnnnicDrawerClose: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogCloseProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    asChild: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<DialogCloseProps> & Readonly<{}>, {}, {}, {}, {}, {
    asChild: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogCloseProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
asChild: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicDrawerClose: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogCloseProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    asChild: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<DialogCloseProps> & Readonly<{}>, {}, {}, {}, {}, {
    asChild: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogCloseProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
asChild: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicDrawerContent: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogContentProps & {
    class?: HTMLAttributes["class"];
    size?: "medium" | "large" | "extra-large" | "giant";
    showOverlay?: boolean;
    }> & Readonly<{
    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
    onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
    onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
    onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
    onOpenAutoFocus?: ((event: Event) => any) | undefined;
    onCloseAutoFocus?: ((event: Event) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    escapeKeyDown: (event: KeyboardEvent) => any;
    pointerDownOutside: (event: PointerDownOutsideEvent) => any;
    focusOutside: (event: FocusOutsideEvent) => any;
    interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
    openAutoFocus: (event: Event) => any;
    closeAutoFocus: (event: Event) => any;
    }, PublicProps, {
    class: HTMLAttributes["class"];
    size: "medium" | "large" | "extra-large" | "giant";
    showOverlay: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<DialogContentProps & {
    class?: HTMLAttributes["class"];
    size?: "medium" | "large" | "extra-large" | "giant";
    showOverlay?: boolean;
    }> & Readonly<{
    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
    onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
    onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
    onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
    onOpenAutoFocus?: ((event: Event) => any) | undefined;
    onCloseAutoFocus?: ((event: Event) => any) | undefined;
    }>, {}, {}, {}, {}, {
    class: HTMLAttributes["class"];
    size: "medium" | "large" | "extra-large" | "giant";
    showOverlay: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogContentProps & {
class?: HTMLAttributes["class"];
size?: "medium" | "large" | "extra-large" | "giant";
showOverlay?: boolean;
}> & Readonly<{
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onOpenAutoFocus?: ((event: Event) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
escapeKeyDown: (event: KeyboardEvent) => any;
pointerDownOutside: (event: PointerDownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
openAutoFocus: (event: Event) => any;
closeAutoFocus: (event: Event) => any;
}, string, {
class: HTMLAttributes["class"];
size: "medium" | "large" | "extra-large" | "giant";
showOverlay: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicDrawerContent: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogContentProps & {
    class?: HTMLAttributes["class"];
    size?: "medium" | "large" | "extra-large" | "giant";
    showOverlay?: boolean;
    }> & Readonly<{
    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
    onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
    onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
    onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
    onOpenAutoFocus?: ((event: Event) => any) | undefined;
    onCloseAutoFocus?: ((event: Event) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    escapeKeyDown: (event: KeyboardEvent) => any;
    pointerDownOutside: (event: PointerDownOutsideEvent) => any;
    focusOutside: (event: FocusOutsideEvent) => any;
    interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
    openAutoFocus: (event: Event) => any;
    closeAutoFocus: (event: Event) => any;
    }, PublicProps, {
    class: HTMLAttributes["class"];
    size: "medium" | "large" | "extra-large" | "giant";
    showOverlay: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<DialogContentProps & {
    class?: HTMLAttributes["class"];
    size?: "medium" | "large" | "extra-large" | "giant";
    showOverlay?: boolean;
    }> & Readonly<{
    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
    onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
    onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
    onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
    onOpenAutoFocus?: ((event: Event) => any) | undefined;
    onCloseAutoFocus?: ((event: Event) => any) | undefined;
    }>, {}, {}, {}, {}, {
    class: HTMLAttributes["class"];
    size: "medium" | "large" | "extra-large" | "giant";
    showOverlay: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogContentProps & {
class?: HTMLAttributes["class"];
size?: "medium" | "large" | "extra-large" | "giant";
showOverlay?: boolean;
}> & Readonly<{
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onOpenAutoFocus?: ((event: Event) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
escapeKeyDown: (event: KeyboardEvent) => any;
pointerDownOutside: (event: PointerDownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
openAutoFocus: (event: Event) => any;
closeAutoFocus: (event: Event) => any;
}, string, {
class: HTMLAttributes["class"];
size: "medium" | "large" | "extra-large" | "giant";
showOverlay: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicDrawerDescription: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogDescriptionProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<DialogDescriptionProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogDescriptionProps & {
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicDrawerDescription: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogDescriptionProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<DialogDescriptionProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogDescriptionProps & {
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicDrawerFooter: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicDrawerFooter: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicDrawerHeader: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
        close?(_: {
            class: string;
        }): any;
    };
});

export declare const unnnicDrawerHeader: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
        close?(_: {
            class: string;
        }): any;
    };
});

export declare const UnnnicDrawerNext: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<UnnnicDrawerNextProps> & Readonly<{
    "onUpdate:open"?: ((open: boolean) => any) | undefined;
    onClose?: (() => any) | undefined;
    onDrag?: ((percentageDragged: number) => any) | undefined;
    onAnimationEnd?: ((open: boolean) => any) | undefined;
    onRelease?: ((open: boolean) => any) | undefined;
    "onUpdate:activeSnapPoint"?: ((val: string | number) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
    "update:open": (open: boolean) => any;
    close: () => any;
    drag: (percentageDragged: number) => any;
    animationEnd: (open: boolean) => any;
    release: (open: boolean) => any;
    "update:activeSnapPoint": (val: string | number) => any;
    }, PublicProps, {
    lazyMount: boolean;
    unmountDelay: number;
    shouldScaleBackground: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<UnnnicDrawerNextProps> & Readonly<{
    "onUpdate:open"?: ((open: boolean) => any) | undefined;
    onClose?: (() => any) | undefined;
    onDrag?: ((percentageDragged: number) => any) | undefined;
    onAnimationEnd?: ((open: boolean) => any) | undefined;
    onRelease?: ((open: boolean) => any) | undefined;
    "onUpdate:activeSnapPoint"?: ((val: string | number) => any) | undefined;
    }>, {}, {}, {}, {}, {
    lazyMount: boolean;
    unmountDelay: number;
    shouldScaleBackground: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<UnnnicDrawerNextProps> & Readonly<{
"onUpdate:open"?: ((open: boolean) => any) | undefined;
onClose?: (() => any) | undefined;
onDrag?: ((percentageDragged: number) => any) | undefined;
onAnimationEnd?: ((open: boolean) => any) | undefined;
onRelease?: ((open: boolean) => any) | undefined;
"onUpdate:activeSnapPoint"?: ((val: string | number) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"update:open": (open: boolean) => any;
close: () => any;
drag: (percentageDragged: number) => any;
animationEnd: (open: boolean) => any;
release: (open: boolean) => any;
"update:activeSnapPoint": (val: string | number) => any;
}, string, {
lazyMount: boolean;
unmountDelay: number;
shouldScaleBackground: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicDrawerNext: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<UnnnicDrawerNextProps> & Readonly<{
    "onUpdate:open"?: ((open: boolean) => any) | undefined;
    onClose?: (() => any) | undefined;
    onDrag?: ((percentageDragged: number) => any) | undefined;
    onAnimationEnd?: ((open: boolean) => any) | undefined;
    onRelease?: ((open: boolean) => any) | undefined;
    "onUpdate:activeSnapPoint"?: ((val: string | number) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
    "update:open": (open: boolean) => any;
    close: () => any;
    drag: (percentageDragged: number) => any;
    animationEnd: (open: boolean) => any;
    release: (open: boolean) => any;
    "update:activeSnapPoint": (val: string | number) => any;
    }, PublicProps, {
    lazyMount: boolean;
    unmountDelay: number;
    shouldScaleBackground: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<UnnnicDrawerNextProps> & Readonly<{
    "onUpdate:open"?: ((open: boolean) => any) | undefined;
    onClose?: (() => any) | undefined;
    onDrag?: ((percentageDragged: number) => any) | undefined;
    onAnimationEnd?: ((open: boolean) => any) | undefined;
    onRelease?: ((open: boolean) => any) | undefined;
    "onUpdate:activeSnapPoint"?: ((val: string | number) => any) | undefined;
    }>, {}, {}, {}, {}, {
    lazyMount: boolean;
    unmountDelay: number;
    shouldScaleBackground: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<UnnnicDrawerNextProps> & Readonly<{
"onUpdate:open"?: ((open: boolean) => any) | undefined;
onClose?: (() => any) | undefined;
onDrag?: ((percentageDragged: number) => any) | undefined;
onAnimationEnd?: ((open: boolean) => any) | undefined;
onRelease?: ((open: boolean) => any) | undefined;
"onUpdate:activeSnapPoint"?: ((val: string | number) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"update:open": (open: boolean) => any;
close: () => any;
drag: (percentageDragged: number) => any;
animationEnd: (open: boolean) => any;
release: (open: boolean) => any;
"update:activeSnapPoint": (val: string | number) => any;
}, string, {
lazyMount: boolean;
unmountDelay: number;
shouldScaleBackground: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

declare interface UnnnicDrawerNextProps extends DrawerRootProps {
    /**
     * When true, the drawer is only mounted while open and stays mounted for
     * `unmountDelay` ms after closing so the exit animation can play. Use it
     * to avoid mounting many drawers eagerly inside lists.
     */
    lazyMount?: boolean;
    /**
     * Delay (ms) before the drawer is unmounted after closing. Should match
     * the leave animation duration. Only applies when `lazyMount` is true.
     */
    unmountDelay?: number;
}

export declare const UnnnicDrawerTitle: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogTitleProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<DialogTitleProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogTitleProps & {
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicDrawerTitle: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogTitleProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<DialogTitleProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogTitleProps & {
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicDropArea: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
    $emit: (event: "update:currentFiles" | "fileChange" | "unsupportedFormat" | "exceededTheMaximumFileSizeLimit", ...args: any[]) => void;
    disabled: boolean;
    subtitle: string;
    acceptMultiple: boolean;
    supportedFormats: string;
    shouldReplace: boolean;
    currentFiles: unknown[];
    maximumUploads: number;
    maxFileSize?: number | undefined;
    $props: {
    readonly disabled?: boolean | undefined;
    readonly subtitle?: string | undefined;
    readonly acceptMultiple?: boolean | undefined;
    readonly supportedFormats?: string | undefined;
    readonly shouldReplace?: boolean | undefined;
    readonly currentFiles?: unknown[] | undefined;
    readonly maximumUploads?: number | undefined;
    readonly maxFileSize?: number | undefined;
    };
    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {
    dropzone: HTMLElement;
    file: HTMLInputElement;
    }, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{}> & Readonly<{}>, {
    $emit: (event: "update:currentFiles" | "fileChange" | "unsupportedFormat" | "exceededTheMaximumFileSizeLimit", ...args: any[]) => void;
    disabled: boolean;
    subtitle: string;
    acceptMultiple: boolean;
    supportedFormats: string;
    shouldReplace: boolean;
    currentFiles: unknown[];
    maximumUploads: number;
    maxFileSize?: number | undefined;
    $props: {
    readonly disabled?: boolean | undefined;
    readonly subtitle?: string | undefined;
    readonly acceptMultiple?: boolean | undefined;
    readonly supportedFormats?: string | undefined;
    readonly shouldReplace?: boolean | undefined;
    readonly currentFiles?: unknown[] | undefined;
    readonly maximumUploads?: number | undefined;
    readonly maxFileSize?: number | undefined;
    };
    }, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
$emit: (event: "update:currentFiles" | "fileChange" | "unsupportedFormat" | "exceededTheMaximumFileSizeLimit", ...args: any[]) => void;
disabled: boolean;
subtitle: string;
acceptMultiple: boolean;
supportedFormats: string;
shouldReplace: boolean;
currentFiles: unknown[];
maximumUploads: number;
maxFileSize?: number | undefined;
$props: {
readonly disabled?: boolean | undefined;
readonly subtitle?: string | undefined;
readonly acceptMultiple?: boolean | undefined;
readonly supportedFormats?: string | undefined;
readonly shouldReplace?: boolean | undefined;
readonly currentFiles?: unknown[] | undefined;
readonly maximumUploads?: number | undefined;
readonly maxFileSize?: number | undefined;
};
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        title?(_: {}): any;
        subtitle?(_: {}): any;
    };
});

export declare const unnnicDropArea: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
    $emit: (event: "update:currentFiles" | "fileChange" | "unsupportedFormat" | "exceededTheMaximumFileSizeLimit", ...args: any[]) => void;
    disabled: boolean;
    subtitle: string;
    acceptMultiple: boolean;
    supportedFormats: string;
    shouldReplace: boolean;
    currentFiles: unknown[];
    maximumUploads: number;
    maxFileSize?: number | undefined;
    $props: {
    readonly disabled?: boolean | undefined;
    readonly subtitle?: string | undefined;
    readonly acceptMultiple?: boolean | undefined;
    readonly supportedFormats?: string | undefined;
    readonly shouldReplace?: boolean | undefined;
    readonly currentFiles?: unknown[] | undefined;
    readonly maximumUploads?: number | undefined;
    readonly maxFileSize?: number | undefined;
    };
    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {
    dropzone: HTMLElement;
    file: HTMLInputElement;
    }, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{}> & Readonly<{}>, {
    $emit: (event: "update:currentFiles" | "fileChange" | "unsupportedFormat" | "exceededTheMaximumFileSizeLimit", ...args: any[]) => void;
    disabled: boolean;
    subtitle: string;
    acceptMultiple: boolean;
    supportedFormats: string;
    shouldReplace: boolean;
    currentFiles: unknown[];
    maximumUploads: number;
    maxFileSize?: number | undefined;
    $props: {
    readonly disabled?: boolean | undefined;
    readonly subtitle?: string | undefined;
    readonly acceptMultiple?: boolean | undefined;
    readonly supportedFormats?: string | undefined;
    readonly shouldReplace?: boolean | undefined;
    readonly currentFiles?: unknown[] | undefined;
    readonly maximumUploads?: number | undefined;
    readonly maxFileSize?: number | undefined;
    };
    }, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
$emit: (event: "update:currentFiles" | "fileChange" | "unsupportedFormat" | "exceededTheMaximumFileSizeLimit", ...args: any[]) => void;
disabled: boolean;
subtitle: string;
acceptMultiple: boolean;
supportedFormats: string;
shouldReplace: boolean;
currentFiles: unknown[];
maximumUploads: number;
maxFileSize?: number | undefined;
$props: {
readonly disabled?: boolean | undefined;
readonly subtitle?: string | undefined;
readonly acceptMultiple?: boolean | undefined;
readonly supportedFormats?: string | undefined;
readonly shouldReplace?: boolean | undefined;
readonly currentFiles?: unknown[] | undefined;
readonly maximumUploads?: number | undefined;
readonly maxFileSize?: number | undefined;
};
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        title?(_: {}): any;
        subtitle?(_: {}): any;
    };
});

export declare const UnnnicDropdown: VueComponent;

export declare const unnnicDropdown: VueComponent;

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

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

export declare const UnnnicEmojiPicker: DefineComponent<Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
close: () => any;
emojiSelected: (emoji: string) => any;
}, string, PublicProps, Readonly<Props> & Readonly<{
onClose?: (() => any) | undefined;
onEmojiSelected?: ((emoji: string) => any) | undefined;
}>, {
locale: string;
position: "top" | "bottom";
returnName: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
emojiPickerRef: HTMLDivElement;
}, HTMLDivElement>;

export declare const unnnicEmojiPicker: DefineComponent<Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
close: () => any;
emojiSelected: (emoji: string) => any;
}, string, PublicProps, Readonly<Props> & Readonly<{
onClose?: (() => any) | undefined;
onEmojiSelected?: ((emoji: string) => any) | undefined;
}>, {
locale: string;
position: "top" | "bottom";
returnName: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
emojiPickerRef: HTMLDivElement;
}, HTMLDivElement>;

export declare const UnnnicFontSize = 16;

export declare const unnnicFontSize = 16;

export declare const UnnnicFormElement: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<FormElementProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    disabled: boolean;
    error: string;
    label: string;
    size: "md" | "sm";
    tooltip: TooltipProps;
    fixedLabel: boolean;
    message: string;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<FormElementProps> & Readonly<{}>, {}, {}, {}, {}, {
    disabled: boolean;
    error: string;
    label: string;
    size: "md" | "sm";
    tooltip: TooltipProps;
    fixedLabel: boolean;
    message: string;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<FormElementProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
disabled: boolean;
error: string;
label: string;
size: "md" | "sm";
tooltip: TooltipProps;
fixedLabel: boolean;
message: string;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
        rightMessage?(_: {}): any;
    };
});

export declare const unnnicFormElement: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<FormElementProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    disabled: boolean;
    error: string;
    label: string;
    size: "md" | "sm";
    tooltip: TooltipProps;
    fixedLabel: boolean;
    message: string;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<FormElementProps> & Readonly<{}>, {}, {}, {}, {}, {
    disabled: boolean;
    error: string;
    label: string;
    size: "md" | "sm";
    tooltip: TooltipProps;
    fixedLabel: boolean;
    message: string;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<FormElementProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
disabled: boolean;
error: string;
label: string;
size: "md" | "sm";
tooltip: TooltipProps;
fixedLabel: boolean;
message: string;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
        rightMessage?(_: {}): any;
    };
});

export declare const UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const unnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const UnnnicIconLoading: DefineComponent<ExtractPropTypes<    {
scheme: {
type: StringConstructor;
default: string;
};
size: {
type: StringConstructor;
default: string;
};
strokeWidth: {
type: NumberConstructor;
default: number;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
scheme: {
type: StringConstructor;
default: string;
};
size: {
type: StringConstructor;
default: string;
};
strokeWidth: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
size: string;
scheme: string;
strokeWidth: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;

export declare const unnnicIconLoading: DefineComponent<ExtractPropTypes<    {
scheme: {
type: StringConstructor;
default: string;
};
size: {
type: StringConstructor;
default: string;
};
strokeWidth: {
type: NumberConstructor;
default: number;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
scheme: {
type: StringConstructor;
default: string;
};
size: {
type: StringConstructor;
default: string;
};
strokeWidth: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
size: string;
scheme: string;
strokeWidth: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;

export declare const UnnnicIconSvg: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const unnnicIconSvg: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const UnnnicImportCard: DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: string;
};
subtitle: {
type: StringConstructor;
default: string;
};
importProgress: {
type: NumberConstructor;
default: number;
};
isImporting: {
type: BooleanConstructor;
default: boolean;
};
canImport: {
type: BooleanConstructor;
default: boolean;
};
canDelete: {
type: BooleanConstructor;
default: boolean;
};
acceptedFormats: {
type: StringConstructor;
default: string;
};
uploadIcon: {
type: StringConstructor;
default: string;
};
}>, {}, {}, {
fileIcon(): any;
}, {
importFile(): void;
handleFileChange(event: any): void;
emitDeletion(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: string;
};
subtitle: {
type: StringConstructor;
default: string;
};
importProgress: {
type: NumberConstructor;
default: number;
};
isImporting: {
type: BooleanConstructor;
default: boolean;
};
canImport: {
type: BooleanConstructor;
default: boolean;
};
canDelete: {
type: BooleanConstructor;
default: boolean;
};
acceptedFormats: {
type: StringConstructor;
default: string;
};
uploadIcon: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
title: string;
subtitle: string;
importProgress: number;
isImporting: boolean;
canImport: boolean;
canDelete: boolean;
acceptedFormats: string;
uploadIcon: string;
}, {}, {
UnnnicButton: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLButtonElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicImportCard: DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: string;
};
subtitle: {
type: StringConstructor;
default: string;
};
importProgress: {
type: NumberConstructor;
default: number;
};
isImporting: {
type: BooleanConstructor;
default: boolean;
};
canImport: {
type: BooleanConstructor;
default: boolean;
};
canDelete: {
type: BooleanConstructor;
default: boolean;
};
acceptedFormats: {
type: StringConstructor;
default: string;
};
uploadIcon: {
type: StringConstructor;
default: string;
};
}>, {}, {}, {
fileIcon(): any;
}, {
importFile(): void;
handleFileChange(event: any): void;
emitDeletion(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: string;
};
subtitle: {
type: StringConstructor;
default: string;
};
importProgress: {
type: NumberConstructor;
default: number;
};
isImporting: {
type: BooleanConstructor;
default: boolean;
};
canImport: {
type: BooleanConstructor;
default: boolean;
};
canDelete: {
type: BooleanConstructor;
default: boolean;
};
acceptedFormats: {
type: StringConstructor;
default: string;
};
uploadIcon: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
title: string;
subtitle: string;
importProgress: number;
isImporting: boolean;
canImport: boolean;
canDelete: boolean;
acceptedFormats: string;
uploadIcon: string;
}, {}, {
UnnnicButton: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLButtonElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicInput: DefineComponent<InputProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
clear: () => any;
"update:modelValue": (value: string) => any;
}, string, PublicProps, Readonly<InputProps> & Readonly<{
onClear?: (() => any) | undefined;
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
}>, {
disabled: boolean;
focus: boolean;
type: InputVariant;
placeholder: string;
label: string;
mask: string | string[];
size: InputSize | string;
tooltip: TooltipProps;
message: string;
modelValue: string;
nativeType: string;
maxlength: number | null;
readonly: boolean;
useFocusProp: boolean;
iconLeft: string;
iconRight: string;
iconLeftClickable: boolean;
iconRightClickable: boolean;
allowTogglePassword: boolean;
showClear: boolean;
errors: string | string[];
hasCloudyColor: boolean;
showMaxlengthCounter: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;

export declare const unnnicInput: DefineComponent<InputProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
clear: () => any;
"update:modelValue": (value: string) => any;
}, string, PublicProps, Readonly<InputProps> & Readonly<{
onClear?: (() => any) | undefined;
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
}>, {
disabled: boolean;
focus: boolean;
type: InputVariant;
placeholder: string;
label: string;
mask: string | string[];
size: InputSize | string;
tooltip: TooltipProps;
message: string;
modelValue: string;
nativeType: string;
maxlength: number | null;
readonly: boolean;
useFocusProp: boolean;
iconLeft: string;
iconRight: string;
iconLeftClickable: boolean;
iconRightClickable: boolean;
allowTogglePassword: boolean;
showClear: boolean;
errors: string | string[];
hasCloudyColor: boolean;
showMaxlengthCounter: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;

export declare const UnnnicInputDatePicker: VueComponent;

export declare const unnnicInputDatePicker: VueComponent;

export declare const UnnnicLabel: VueComponent;

export declare const unnnicLabel: VueComponent;

export declare const UnnniclanguageSelect: VueComponent;

export declare const unnniclanguageSelect: VueComponent;

export declare const UnnnicModal: DefineComponent<ExtractPropTypes<    {
text: {
type: StringConstructor;
default: null;
};
modalIcon: {
type: StringConstructor;
default: null;
};
closeIcon: {
type: BooleanConstructor;
default: boolean;
};
description: {
type: StringConstructor;
default: null;
};
alertMessage: {
type: StringConstructor;
default: null;
};
showModal: {
type: BooleanConstructor;
default: boolean;
};
scheme: {
type: StringConstructor;
default: null;
};
persistent: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {
hasAlertMessage(): boolean;
hasButton(): boolean;
hasIcon(): boolean;
}, {
mobileAnimateReset(): void;
mobileAnimateOpen(): void;
mobileAnimateClose(): Promise<any>;
onOutsideCloseClick(): void;
onCloseClick(): Promise<void>;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
text: {
type: StringConstructor;
default: null;
};
modalIcon: {
type: StringConstructor;
default: null;
};
closeIcon: {
type: BooleanConstructor;
default: boolean;
};
description: {
type: StringConstructor;
default: null;
};
alertMessage: {
type: StringConstructor;
default: null;
};
showModal: {
type: BooleanConstructor;
default: boolean;
};
scheme: {
type: StringConstructor;
default: null;
};
persistent: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
text: string;
scheme: string;
description: string;
modalIcon: string;
closeIcon: boolean;
alertMessage: string;
showModal: boolean;
persistent: boolean;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicModal: DefineComponent<ExtractPropTypes<    {
text: {
type: StringConstructor;
default: null;
};
modalIcon: {
type: StringConstructor;
default: null;
};
closeIcon: {
type: BooleanConstructor;
default: boolean;
};
description: {
type: StringConstructor;
default: null;
};
alertMessage: {
type: StringConstructor;
default: null;
};
showModal: {
type: BooleanConstructor;
default: boolean;
};
scheme: {
type: StringConstructor;
default: null;
};
persistent: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {
hasAlertMessage(): boolean;
hasButton(): boolean;
hasIcon(): boolean;
}, {
mobileAnimateReset(): void;
mobileAnimateOpen(): void;
mobileAnimateClose(): Promise<any>;
onOutsideCloseClick(): void;
onCloseClick(): Promise<void>;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
text: {
type: StringConstructor;
default: null;
};
modalIcon: {
type: StringConstructor;
default: null;
};
closeIcon: {
type: BooleanConstructor;
default: boolean;
};
description: {
type: StringConstructor;
default: null;
};
alertMessage: {
type: StringConstructor;
default: null;
};
showModal: {
type: BooleanConstructor;
default: boolean;
};
scheme: {
type: StringConstructor;
default: null;
};
persistent: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
text: string;
scheme: string;
description: string;
modalIcon: string;
closeIcon: boolean;
alertMessage: string;
showModal: boolean;
persistent: boolean;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicModalDialog: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
required: true;
};
persistent: {
type: BooleanConstructor;
default: boolean;
};
type: {
type: StringConstructor;
default: string;
validate(type: any): boolean;
};
size: {
type: StringConstructor;
default: string;
validate(size: any): boolean;
};
title: {
type: StringConstructor;
default: string;
};
icon: {
type: StringConstructor;
default: string;
};
iconScheme: {
type: StringConstructor;
default: string;
};
showCloseIcon: {
type: BooleanConstructor;
default: boolean;
};
showActionsDivider: {
type: BooleanConstructor;
default: boolean;
};
primaryButtonProps: {
type: ObjectConstructor;
default: () => {};
};
hideSecondaryButton: {
type: BooleanConstructor;
default: boolean;
};
secondaryButtonProps: {
type: ObjectConstructor;
default: () => {};
};
}>, {}, {
defaultTranslations: {
cancel: {
'pt-br': string;
en: string;
es: string;
};
};
primaryButtonTypeMapper: {
success: string;
warning: string;
attention: string;
};
}, {}, {
close(): void;
persistentHandler(event: any): void;
}, {
props: {
locale: {
type: StringConstructor;
};
translations: {
type: ObjectConstructor;
};
};
methods: {
i18n(...args: any[]): any;
};
}, ComponentOptionsMixin, ("update:modelValue" | "primaryButtonClick" | "secondaryButtonClick")[], "update:modelValue" | "primaryButtonClick" | "secondaryButtonClick", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
required: true;
};
persistent: {
type: BooleanConstructor;
default: boolean;
};
type: {
type: StringConstructor;
default: string;
validate(type: any): boolean;
};
size: {
type: StringConstructor;
default: string;
validate(size: any): boolean;
};
title: {
type: StringConstructor;
default: string;
};
icon: {
type: StringConstructor;
default: string;
};
iconScheme: {
type: StringConstructor;
default: string;
};
showCloseIcon: {
type: BooleanConstructor;
default: boolean;
};
showActionsDivider: {
type: BooleanConstructor;
default: boolean;
};
primaryButtonProps: {
type: ObjectConstructor;
default: () => {};
};
hideSecondaryButton: {
type: BooleanConstructor;
default: boolean;
};
secondaryButtonProps: {
type: ObjectConstructor;
default: () => {};
};
}>> & Readonly<{
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
onPrimaryButtonClick?: ((...args: any[]) => any) | undefined;
onSecondaryButtonClick?: ((...args: any[]) => any) | undefined;
}>, {
type: string;
title: string;
size: string;
icon: string;
iconScheme: string;
persistent: boolean;
showCloseIcon: boolean;
showActionsDivider: boolean;
primaryButtonProps: Record<string, any>;
hideSecondaryButton: boolean;
secondaryButtonProps: Record<string, any>;
}, {}, {
UnnnicButton: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLButtonElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicDialog: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogRootProps & {
lazyMount?: boolean;
unmountDelay?: number;
}> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
}, PublicProps, {
lazyMount: boolean;
unmountDelay: number;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<DialogRootProps & {
lazyMount?: boolean;
unmountDelay?: number;
}> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
}>, {}, {}, {}, {}, {
lazyMount: boolean;
unmountDelay: number;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogRootProps & {
lazyMount?: boolean;
unmountDelay?: number;
}> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
}, string, {
lazyMount: boolean;
unmountDelay: number;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicDialogContent: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogContentProps & {
parentClass?: HTMLAttributes["class"];
class?: HTMLAttributes["class"];
size?: "small" | "medium" | "large";
}> & Readonly<{
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onOpenAutoFocus?: ((event: Event) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
escapeKeyDown: (event: KeyboardEvent) => any;
pointerDownOutside: (event: PointerDownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
openAutoFocus: (event: Event) => any;
closeAutoFocus: (event: Event) => any;
}, PublicProps, {
class: HTMLAttributes["class"];
size: "small" | "medium" | "large";
parentClass: HTMLAttributes["class"];
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<DialogContentProps & {
parentClass?: HTMLAttributes["class"];
class?: HTMLAttributes["class"];
size?: "small" | "medium" | "large";
}> & Readonly<{
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onOpenAutoFocus?: ((event: Event) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {}, {}, {}, {}, {
class: HTMLAttributes["class"];
size: "small" | "medium" | "large";
parentClass: HTMLAttributes["class"];
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogContentProps & {
parentClass?: HTMLAttributes["class"];
class?: HTMLAttributes["class"];
size?: "small" | "medium" | "large";
}> & Readonly<{
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onOpenAutoFocus?: ((event: Event) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
escapeKeyDown: (event: KeyboardEvent) => any;
pointerDownOutside: (event: PointerDownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
openAutoFocus: (event: Event) => any;
closeAutoFocus: (event: Event) => any;
}, string, {
class: HTMLAttributes["class"];
size: "small" | "medium" | "large";
parentClass: HTMLAttributes["class"];
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicDialogHeader: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
class?: HTMLAttributes["class"];
divider?: boolean;
type?: "default" | "success" | "warning" | "attention";
closeButton?: boolean;
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
type: "default" | "success" | "warning" | "attention";
divider: boolean;
closeButton: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{
class?: HTMLAttributes["class"];
divider?: boolean;
type?: "default" | "success" | "warning" | "attention";
closeButton?: boolean;
}> & Readonly<{}>, {}, {}, {}, {}, {
type: "default" | "success" | "warning" | "attention";
divider: boolean;
closeButton: boolean;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
divider?: boolean;
type?: "default" | "success" | "warning" | "attention";
closeButton?: boolean;
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
type: "default" | "success" | "warning" | "attention";
divider: boolean;
closeButton: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicDialogTitle: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogTitleProps & {
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<DialogTitleProps & {
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, {}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogTitleProps & {
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicDialogFooter: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
class?: HTMLAttributes["class"];
divider?: boolean;
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
divider: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{
class?: HTMLAttributes["class"];
divider?: boolean;
}> & Readonly<{}>, {}, {}, {}, {}, {
divider: boolean;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
divider?: boolean;
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
divider: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicModalDialog: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
required: true;
};
persistent: {
type: BooleanConstructor;
default: boolean;
};
type: {
type: StringConstructor;
default: string;
validate(type: any): boolean;
};
size: {
type: StringConstructor;
default: string;
validate(size: any): boolean;
};
title: {
type: StringConstructor;
default: string;
};
icon: {
type: StringConstructor;
default: string;
};
iconScheme: {
type: StringConstructor;
default: string;
};
showCloseIcon: {
type: BooleanConstructor;
default: boolean;
};
showActionsDivider: {
type: BooleanConstructor;
default: boolean;
};
primaryButtonProps: {
type: ObjectConstructor;
default: () => {};
};
hideSecondaryButton: {
type: BooleanConstructor;
default: boolean;
};
secondaryButtonProps: {
type: ObjectConstructor;
default: () => {};
};
}>, {}, {
defaultTranslations: {
cancel: {
'pt-br': string;
en: string;
es: string;
};
};
primaryButtonTypeMapper: {
success: string;
warning: string;
attention: string;
};
}, {}, {
close(): void;
persistentHandler(event: any): void;
}, {
props: {
locale: {
type: StringConstructor;
};
translations: {
type: ObjectConstructor;
};
};
methods: {
i18n(...args: any[]): any;
};
}, ComponentOptionsMixin, ("update:modelValue" | "primaryButtonClick" | "secondaryButtonClick")[], "update:modelValue" | "primaryButtonClick" | "secondaryButtonClick", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
required: true;
};
persistent: {
type: BooleanConstructor;
default: boolean;
};
type: {
type: StringConstructor;
default: string;
validate(type: any): boolean;
};
size: {
type: StringConstructor;
default: string;
validate(size: any): boolean;
};
title: {
type: StringConstructor;
default: string;
};
icon: {
type: StringConstructor;
default: string;
};
iconScheme: {
type: StringConstructor;
default: string;
};
showCloseIcon: {
type: BooleanConstructor;
default: boolean;
};
showActionsDivider: {
type: BooleanConstructor;
default: boolean;
};
primaryButtonProps: {
type: ObjectConstructor;
default: () => {};
};
hideSecondaryButton: {
type: BooleanConstructor;
default: boolean;
};
secondaryButtonProps: {
type: ObjectConstructor;
default: () => {};
};
}>> & Readonly<{
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
onPrimaryButtonClick?: ((...args: any[]) => any) | undefined;
onSecondaryButtonClick?: ((...args: any[]) => any) | undefined;
}>, {
type: string;
title: string;
size: string;
icon: string;
iconScheme: string;
persistent: boolean;
showCloseIcon: boolean;
showActionsDivider: boolean;
primaryButtonProps: Record<string, any>;
hideSecondaryButton: boolean;
secondaryButtonProps: Record<string, any>;
}, {}, {
UnnnicButton: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLButtonElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicDialog: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogRootProps & {
lazyMount?: boolean;
unmountDelay?: number;
}> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
}, PublicProps, {
lazyMount: boolean;
unmountDelay: number;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<DialogRootProps & {
lazyMount?: boolean;
unmountDelay?: number;
}> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
}>, {}, {}, {}, {}, {
lazyMount: boolean;
unmountDelay: number;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogRootProps & {
lazyMount?: boolean;
unmountDelay?: number;
}> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
}, string, {
lazyMount: boolean;
unmountDelay: number;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicDialogContent: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogContentProps & {
parentClass?: HTMLAttributes["class"];
class?: HTMLAttributes["class"];
size?: "small" | "medium" | "large";
}> & Readonly<{
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onOpenAutoFocus?: ((event: Event) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
escapeKeyDown: (event: KeyboardEvent) => any;
pointerDownOutside: (event: PointerDownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
openAutoFocus: (event: Event) => any;
closeAutoFocus: (event: Event) => any;
}, PublicProps, {
class: HTMLAttributes["class"];
size: "small" | "medium" | "large";
parentClass: HTMLAttributes["class"];
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<DialogContentProps & {
parentClass?: HTMLAttributes["class"];
class?: HTMLAttributes["class"];
size?: "small" | "medium" | "large";
}> & Readonly<{
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onOpenAutoFocus?: ((event: Event) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {}, {}, {}, {}, {
class: HTMLAttributes["class"];
size: "small" | "medium" | "large";
parentClass: HTMLAttributes["class"];
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogContentProps & {
parentClass?: HTMLAttributes["class"];
class?: HTMLAttributes["class"];
size?: "small" | "medium" | "large";
}> & Readonly<{
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onOpenAutoFocus?: ((event: Event) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
escapeKeyDown: (event: KeyboardEvent) => any;
pointerDownOutside: (event: PointerDownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
openAutoFocus: (event: Event) => any;
closeAutoFocus: (event: Event) => any;
}, string, {
class: HTMLAttributes["class"];
size: "small" | "medium" | "large";
parentClass: HTMLAttributes["class"];
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicDialogHeader: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
class?: HTMLAttributes["class"];
divider?: boolean;
type?: "default" | "success" | "warning" | "attention";
closeButton?: boolean;
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
type: "default" | "success" | "warning" | "attention";
divider: boolean;
closeButton: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{
class?: HTMLAttributes["class"];
divider?: boolean;
type?: "default" | "success" | "warning" | "attention";
closeButton?: boolean;
}> & Readonly<{}>, {}, {}, {}, {}, {
type: "default" | "success" | "warning" | "attention";
divider: boolean;
closeButton: boolean;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
divider?: boolean;
type?: "default" | "success" | "warning" | "attention";
closeButton?: boolean;
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
type: "default" | "success" | "warning" | "attention";
divider: boolean;
closeButton: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicDialogTitle: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<DialogTitleProps & {
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<DialogTitleProps & {
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, {}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<DialogTitleProps & {
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicDialogFooter: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
class?: HTMLAttributes["class"];
divider?: boolean;
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
divider: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{
class?: HTMLAttributes["class"];
divider?: boolean;
}> & Readonly<{}>, {}, {}, {}, {}, {
divider: boolean;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
divider?: boolean;
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
divider: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicModalNext: DefineComponent<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
};
url: StringConstructor;
icon: StringConstructor;
scheme: StringConstructor;
title: StringConstructor;
description: StringConstructor;
validate: StringConstructor;
validatePlaceholder: StringConstructor;
validateLabel: StringConstructor;
actionPrimaryLabel: StringConstructor;
actionPrimaryLoading: BooleanConstructor;
actionPrimaryButtonType: {
type: StringConstructor;
default: string;
};
actionSecondaryLabel: StringConstructor;
showCloseButton: BooleanConstructor;
}>, {}, {
confirmText: string;
}, {
isPersistent(): any;
buttonType(): "" | "alert" | "danger";
disabled(): boolean;
}, {
closeByDarkBackground(): void;
close(): void;
justClose(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, "close"[], "close", PublicProps, Readonly<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
};
url: StringConstructor;
icon: StringConstructor;
scheme: StringConstructor;
title: StringConstructor;
description: StringConstructor;
validate: StringConstructor;
validatePlaceholder: StringConstructor;
validateLabel: StringConstructor;
actionPrimaryLabel: StringConstructor;
actionPrimaryLoading: BooleanConstructor;
actionPrimaryButtonType: {
type: StringConstructor;
default: string;
};
actionSecondaryLabel: StringConstructor;
showCloseButton: BooleanConstructor;
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
}>, {
type: string;
actionPrimaryLoading: boolean;
showCloseButton: boolean;
actionPrimaryButtonType: string;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
UnnnicInput: DefineComponent<InputProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
clear: () => any;
"update:modelValue": (value: string) => any;
}, string, PublicProps, Readonly<InputProps> & Readonly<{
onClear?: (() => any) | undefined;
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
}>, {
disabled: boolean;
focus: boolean;
type: InputVariant;
placeholder: string;
label: string;
mask: string | string[];
size: InputSize | string;
tooltip: TooltipProps;
message: string;
modelValue: string;
nativeType: string;
maxlength: number | null;
readonly: boolean;
useFocusProp: boolean;
iconLeft: string;
iconRight: string;
iconLeftClickable: boolean;
iconRightClickable: boolean;
allowTogglePassword: boolean;
showClear: boolean;
errors: string | string[];
hasCloudyColor: boolean;
showMaxlengthCounter: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;
UnnnicButton: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLButtonElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicModalNext: DefineComponent<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
};
url: StringConstructor;
icon: StringConstructor;
scheme: StringConstructor;
title: StringConstructor;
description: StringConstructor;
validate: StringConstructor;
validatePlaceholder: StringConstructor;
validateLabel: StringConstructor;
actionPrimaryLabel: StringConstructor;
actionPrimaryLoading: BooleanConstructor;
actionPrimaryButtonType: {
type: StringConstructor;
default: string;
};
actionSecondaryLabel: StringConstructor;
showCloseButton: BooleanConstructor;
}>, {}, {
confirmText: string;
}, {
isPersistent(): any;
buttonType(): "" | "alert" | "danger";
disabled(): boolean;
}, {
closeByDarkBackground(): void;
close(): void;
justClose(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, "close"[], "close", PublicProps, Readonly<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
};
url: StringConstructor;
icon: StringConstructor;
scheme: StringConstructor;
title: StringConstructor;
description: StringConstructor;
validate: StringConstructor;
validatePlaceholder: StringConstructor;
validateLabel: StringConstructor;
actionPrimaryLabel: StringConstructor;
actionPrimaryLoading: BooleanConstructor;
actionPrimaryButtonType: {
type: StringConstructor;
default: string;
};
actionSecondaryLabel: StringConstructor;
showCloseButton: BooleanConstructor;
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
}>, {
type: string;
actionPrimaryLoading: boolean;
showCloseButton: boolean;
actionPrimaryButtonType: string;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
UnnnicInput: DefineComponent<InputProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
clear: () => any;
"update:modelValue": (value: string) => any;
}, string, PublicProps, Readonly<InputProps> & Readonly<{
onClear?: (() => any) | undefined;
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
}>, {
disabled: boolean;
focus: boolean;
type: InputVariant;
placeholder: string;
label: string;
mask: string | string[];
size: InputSize | string;
tooltip: TooltipProps;
message: string;
modelValue: string;
nativeType: string;
maxlength: number | null;
readonly: boolean;
useFocusProp: boolean;
iconLeft: string;
iconRight: string;
iconLeftClickable: boolean;
iconRightClickable: boolean;
allowTogglePassword: boolean;
showClear: boolean;
errors: string | string[];
hasCloudyColor: boolean;
showMaxlengthCounter: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLElement>;
UnnnicButton: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLButtonElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicMultiSelect: VueComponent;

export declare const unnnicMultiSelect: VueComponent;

export declare const UnnnicNavigator: DefineComponent<ExtractPropTypes<    {
pages: {
type: ArrayConstructor;
required: true;
};
activePage: {
type: StringConstructor;
required: true;
};
}>, {}, {}, {
activePageIndex(): number;
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
pages: {
type: ArrayConstructor;
required: true;
};
activePage: {
type: StringConstructor;
required: true;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicNavigator: DefineComponent<ExtractPropTypes<    {
pages: {
type: ArrayConstructor;
required: true;
};
activePage: {
type: StringConstructor;
required: true;
};
}>, {}, {}, {
activePageIndex(): number;
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
pages: {
type: ArrayConstructor;
required: true;
};
activePage: {
type: StringConstructor;
required: true;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicPageHeader: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<PageHeaderProps> & Readonly<{
    onBack?: (() => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
    back: () => any;
    }, PublicProps, {
    description: string;
    hasBackButton: boolean;
    hideDivider: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<PageHeaderProps> & Readonly<{
    onBack?: (() => any) | undefined;
    }>, {}, {}, {}, {}, {
    description: string;
    hasBackButton: boolean;
    hideDivider: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<PageHeaderProps> & Readonly<{
onBack?: (() => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
back: () => any;
}, string, {
description: string;
hasBackButton: boolean;
hideDivider: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        infos?(_: {}): any;
        tag?(_: {}): any;
        actions?(_: {}): any;
        tabs?(_: {}): any;
    };
});

export declare const unnnicPageHeader: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<PageHeaderProps> & Readonly<{
    onBack?: (() => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
    back: () => any;
    }, PublicProps, {
    description: string;
    hasBackButton: boolean;
    hideDivider: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<PageHeaderProps> & Readonly<{
    onBack?: (() => any) | undefined;
    }>, {}, {}, {}, {}, {
    description: string;
    hasBackButton: boolean;
    hideDivider: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<PageHeaderProps> & Readonly<{
onBack?: (() => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
back: () => any;
}, string, {
description: string;
hasBackButton: boolean;
hideDivider: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        infos?(_: {}): any;
        tag?(_: {}): any;
        actions?(_: {}): any;
        tabs?(_: {}): any;
    };
});

export declare const UnnnicPagination: DefineComponent<PaginationProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:model-value": (value: number) => any;
}, string, PublicProps, Readonly<PaginationProps> & Readonly<{
"onUpdate:model-value"?: ((value: number) => any) | undefined;
}>, {
disabled: boolean;
modelValue: number;
max: number;
show: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare const unnnicPagination: DefineComponent<PaginationProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:model-value": (value: number) => any;
}, string, PublicProps, Readonly<PaginationProps> & Readonly<{
"onUpdate:model-value"?: ((value: number) => any) | undefined;
}>, {
disabled: boolean;
modelValue: number;
max: number;
show: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare interface UnnnicPlugin {
    install(app: App, options?: UnnnicPluginOptions): void;
    [key: string]: any;
}

export declare interface UnnnicPluginOptions {
    teleportTarget?: TeleportTarget | null;
}

export declare const UnnnicPopover: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<PopoverRootProps> & Readonly<{
    "onUpdate:open"?: ((value: boolean) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:open": (value: boolean) => any;
    }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<PopoverRootProps> & Readonly<{
    "onUpdate:open"?: ((value: boolean) => any) | undefined;
    }>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<PopoverRootProps> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicPopover: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<PopoverRootProps> & Readonly<{
    "onUpdate:open"?: ((value: boolean) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:open": (value: boolean) => any;
    }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<PopoverRootProps> & Readonly<{
    "onUpdate:open"?: ((value: boolean) => any) | undefined;
    }>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<PopoverRootProps> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicPopoverContent: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<PopoverContentProps & {
    class?: HTMLAttributes["class"];
    size?: string;
    width?: string;
    }> & Readonly<{
    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
    onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
    onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
    onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
    onOpenAutoFocus?: ((event: Event) => any) | undefined;
    onCloseAutoFocus?: ((event: Event) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    escapeKeyDown: (event: KeyboardEvent) => any;
    pointerDownOutside: (event: PointerDownOutsideEvent) => any;
    focusOutside: (event: FocusOutsideEvent) => any;
    interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
    openAutoFocus: (event: Event) => any;
    closeAutoFocus: (event: Event) => any;
    }, PublicProps, {
    class: HTMLAttributes["class"];
    sideOffset: number;
    align: "center" | "start" | "end";
    size: string;
    width: string;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
    footerContainer: HTMLDivElement;
    }, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<PopoverContentProps & {
    class?: HTMLAttributes["class"];
    size?: string;
    width?: string;
    }> & Readonly<{
    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
    onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
    onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
    onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
    onOpenAutoFocus?: ((event: Event) => any) | undefined;
    onCloseAutoFocus?: ((event: Event) => any) | undefined;
    }>, {}, {}, {}, {}, {
    class: HTMLAttributes["class"];
    sideOffset: number;
    align: "center" | "start" | "end";
    size: string;
    width: string;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<PopoverContentProps & {
class?: HTMLAttributes["class"];
size?: string;
width?: string;
}> & Readonly<{
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onOpenAutoFocus?: ((event: Event) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
escapeKeyDown: (event: KeyboardEvent) => any;
pointerDownOutside: (event: PointerDownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
openAutoFocus: (event: Event) => any;
closeAutoFocus: (event: Event) => any;
}, string, {
class: HTMLAttributes["class"];
sideOffset: number;
align: "center" | "start" | "end";
size: string;
width: string;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicPopoverContent: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<PopoverContentProps & {
    class?: HTMLAttributes["class"];
    size?: string;
    width?: string;
    }> & Readonly<{
    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
    onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
    onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
    onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
    onOpenAutoFocus?: ((event: Event) => any) | undefined;
    onCloseAutoFocus?: ((event: Event) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    escapeKeyDown: (event: KeyboardEvent) => any;
    pointerDownOutside: (event: PointerDownOutsideEvent) => any;
    focusOutside: (event: FocusOutsideEvent) => any;
    interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
    openAutoFocus: (event: Event) => any;
    closeAutoFocus: (event: Event) => any;
    }, PublicProps, {
    class: HTMLAttributes["class"];
    sideOffset: number;
    align: "center" | "start" | "end";
    size: string;
    width: string;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
    footerContainer: HTMLDivElement;
    }, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<PopoverContentProps & {
    class?: HTMLAttributes["class"];
    size?: string;
    width?: string;
    }> & Readonly<{
    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
    onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
    onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
    onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
    onOpenAutoFocus?: ((event: Event) => any) | undefined;
    onCloseAutoFocus?: ((event: Event) => any) | undefined;
    }>, {}, {}, {}, {}, {
    class: HTMLAttributes["class"];
    sideOffset: number;
    align: "center" | "start" | "end";
    size: string;
    width: string;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<PopoverContentProps & {
class?: HTMLAttributes["class"];
size?: string;
width?: string;
}> & Readonly<{
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onOpenAutoFocus?: ((event: Event) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
escapeKeyDown: (event: KeyboardEvent) => any;
pointerDownOutside: (event: PointerDownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
openAutoFocus: (event: Event) => any;
closeAutoFocus: (event: Event) => any;
}, string, {
class: HTMLAttributes["class"];
sideOffset: number;
align: "center" | "start" | "end";
size: string;
width: string;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicPopoverFooter: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
        default?(_: {}): any;
    };
});

export declare const unnnicPopoverFooter: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
        default?(_: {}): any;
    };
});

export declare const UnnnicPopoverOption: VueComponent;

export declare const unnnicPopoverOption: VueComponent;

export declare const UnnnicPopoverTrigger: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<PopoverTriggerProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<PopoverTriggerProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<PopoverTriggerProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicPopoverTrigger: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<PopoverTriggerProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<PopoverTriggerProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<PopoverTriggerProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicProgressBar: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: NumberConstructor;
};
type: {
type: StringConstructor;
default: string;
};
title: {
type: StringConstructor;
};
subtitle: {
type: StringConstructor;
};
inline: {
type: BooleanConstructor;
};
canClose: {
type: BooleanConstructor;
};
}>, {}, {}, {
percentage(): number;
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: NumberConstructor;
};
type: {
type: StringConstructor;
default: string;
};
title: {
type: StringConstructor;
};
subtitle: {
type: StringConstructor;
};
inline: {
type: BooleanConstructor;
};
canClose: {
type: BooleanConstructor;
};
}>> & Readonly<{}>, {
type: string;
inline: boolean;
canClose: boolean;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicProgressBar: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: NumberConstructor;
};
type: {
type: StringConstructor;
default: string;
};
title: {
type: StringConstructor;
};
subtitle: {
type: StringConstructor;
};
inline: {
type: BooleanConstructor;
};
canClose: {
type: BooleanConstructor;
};
}>, {}, {}, {
percentage(): number;
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: NumberConstructor;
};
type: {
type: StringConstructor;
default: string;
};
title: {
type: StringConstructor;
};
subtitle: {
type: StringConstructor;
};
inline: {
type: BooleanConstructor;
};
canClose: {
type: BooleanConstructor;
};
}>> & Readonly<{}>, {
type: string;
inline: boolean;
canClose: boolean;
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicRadio: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<RadioProps> & Readonly<{
    "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:modelValue": (value: string | number) => any;
    }, PublicProps, {
    disabled: boolean;
    value: string | number;
    label: string;
    name: string;
    modelValue: string | number;
    helper: string;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<RadioProps> & Readonly<{
    "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
    }>, {}, {}, {}, {}, {
    disabled: boolean;
    value: string | number;
    label: string;
    name: string;
    modelValue: string | number;
    helper: string;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<RadioProps> & Readonly<{
"onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: string | number) => any;
}, string, {
disabled: boolean;
value: string | number;
label: string;
name: string;
modelValue: string | number;
helper: string;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicRadio: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<RadioProps> & Readonly<{
    "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:modelValue": (value: string | number) => any;
    }, PublicProps, {
    disabled: boolean;
    value: string | number;
    label: string;
    name: string;
    modelValue: string | number;
    helper: string;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<RadioProps> & Readonly<{
    "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
    }>, {}, {}, {}, {}, {
    disabled: boolean;
    value: string | number;
    label: string;
    name: string;
    modelValue: string | number;
    helper: string;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<RadioProps> & Readonly<{
"onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: string | number) => any;
}, string, {
disabled: boolean;
value: string | number;
label: string;
name: string;
modelValue: string | number;
helper: string;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicRadioGroup: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<RadioGroupProps> & Readonly<{
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:modelValue": (...args: any[]) => void;
    }, PublicProps, {
    label: string;
    name: string;
    modelValue: string | number;
    helper: string;
    state: "horizontal" | "vertical";
    labelTooltip: TooltipProps;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<RadioGroupProps> & Readonly<{
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    }>, {}, {}, {}, {}, {
    label: string;
    name: string;
    modelValue: string | number;
    helper: string;
    state: "horizontal" | "vertical";
    labelTooltip: TooltipProps;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<RadioGroupProps> & Readonly<{
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (...args: any[]) => void;
}, string, {
label: string;
name: string;
modelValue: string | number;
helper: string;
state: "horizontal" | "vertical";
labelTooltip: TooltipProps;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicRadioGroup: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<RadioGroupProps> & Readonly<{
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:modelValue": (...args: any[]) => void;
    }, PublicProps, {
    label: string;
    name: string;
    modelValue: string | number;
    helper: string;
    state: "horizontal" | "vertical";
    labelTooltip: TooltipProps;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<RadioGroupProps> & Readonly<{
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    }>, {}, {}, {}, {}, {
    label: string;
    name: string;
    modelValue: string | number;
    helper: string;
    state: "horizontal" | "vertical";
    labelTooltip: TooltipProps;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<RadioGroupProps> & Readonly<{
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (...args: any[]) => void;
}, string, {
label: string;
name: string;
modelValue: string | number;
helper: string;
state: "horizontal" | "vertical";
labelTooltip: TooltipProps;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicSegmentedControl: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TabsRootProps<string | number>> & Readonly<{
    "onUpdate:modelValue"?: ((payload: string | number) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:modelValue": (payload: string | number) => any;
    }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<TabsRootProps<string | number>> & Readonly<{
    "onUpdate:modelValue"?: ((payload: string | number) => any) | undefined;
    }>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<TabsRootProps<string | number>> & Readonly<{
"onUpdate:modelValue"?: ((payload: string | number) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (payload: string | number) => any;
}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicSegmentedControl: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TabsRootProps<string | number>> & Readonly<{
    "onUpdate:modelValue"?: ((payload: string | number) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:modelValue": (payload: string | number) => any;
    }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<TabsRootProps<string | number>> & Readonly<{
    "onUpdate:modelValue"?: ((payload: string | number) => any) | undefined;
    }>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<TabsRootProps<string | number>> & Readonly<{
"onUpdate:modelValue"?: ((payload: string | number) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (payload: string | number) => any;
}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicSegmentedControlContent: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TabsContentProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<TabsContentProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<TabsContentProps & {
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicSegmentedControlContent: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TabsContentProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<TabsContentProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<TabsContentProps & {
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicSegmentedControlList: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TabsListProps & {
    size?: "small" | "medium";
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    size: "small" | "medium";
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<TabsListProps & {
    size?: "small" | "medium";
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {
    size: "small" | "medium";
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<TabsListProps & {
size?: "small" | "medium";
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
size: "small" | "medium";
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicSegmentedControlList: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TabsListProps & {
    size?: "small" | "medium";
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    size: "small" | "medium";
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<TabsListProps & {
    size?: "small" | "medium";
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {
    size: "small" | "medium";
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<TabsListProps & {
size?: "small" | "medium";
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
size: "small" | "medium";
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicSegmentedControlTrigger: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TabsTriggerProps & {
    size?: "small" | "medium";
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<TabsTriggerProps & {
    size?: "small" | "medium";
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<TabsTriggerProps & {
size?: "small" | "medium";
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicSegmentedControlTrigger: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TabsTriggerProps & {
    size?: "small" | "medium";
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<TabsTriggerProps & {
    size?: "small" | "medium";
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<TabsTriggerProps & {
size?: "small" | "medium";
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicSelect: VueComponent;

export declare const unnnicSelect: VueComponent;

export declare const UnnnicSelectItem: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<SelectItemProps> & Readonly<{
    onClick?: (() => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    click: () => any;
    }, PublicProps, {
    size: string;
    selectable: boolean;
    active: boolean;
    textFocused: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLDivElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<SelectItemProps> & Readonly<{
    onClick?: (() => any) | undefined;
    }>, {}, {}, {}, {}, {
    size: string;
    selectable: boolean;
    active: boolean;
    textFocused: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<SelectItemProps> & Readonly<{
onClick?: (() => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: () => any;
}, string, {
size: string;
selectable: boolean;
active: boolean;
textFocused: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicSelectItem: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<SelectItemProps> & Readonly<{
    onClick?: (() => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    click: () => any;
    }, PublicProps, {
    size: string;
    selectable: boolean;
    active: boolean;
    textFocused: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLDivElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<SelectItemProps> & Readonly<{
    onClick?: (() => any) | undefined;
    }>, {}, {}, {}, {}, {
    size: string;
    selectable: boolean;
    active: boolean;
    textFocused: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<SelectItemProps> & Readonly<{
onClick?: (() => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: () => any;
}, string, {
size: string;
selectable: boolean;
active: boolean;
textFocused: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicSelectSmart: VueComponent;

export declare const unnnicSelectSmart: VueComponent;

export declare const UnnnicSelectTime: VueComponent;

export declare const unnnicSelectTime: VueComponent;

export declare const UnnnicSidebar: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
    $emit: (event: "navigate", ...args: any[]) => void;
    width: string;
    active: Record<string, any>;
    position: string;
    autoNavigateFirstChild: boolean;
    items: unknown[];
    $props: {
    readonly width?: string | undefined;
    readonly active?: Record<string, any> | undefined;
    readonly position?: string | undefined;
    readonly autoNavigateFirstChild?: boolean | undefined;
    readonly items?: unknown[] | undefined;
    };
    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{}> & Readonly<{}>, {
    $emit: (event: "navigate", ...args: any[]) => void;
    width: string;
    active: Record<string, any>;
    position: string;
    autoNavigateFirstChild: boolean;
    items: unknown[];
    $props: {
    readonly width?: string | undefined;
    readonly active?: Record<string, any> | undefined;
    readonly position?: string | undefined;
    readonly autoNavigateFirstChild?: boolean | undefined;
    readonly items?: unknown[] | undefined;
    };
    }, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
$emit: (event: "navigate", ...args: any[]) => void;
width: string;
active: Record<string, any>;
position: string;
autoNavigateFirstChild: boolean;
items: unknown[];
$props: {
readonly width?: string | undefined;
readonly active?: Record<string, any> | undefined;
readonly position?: string | undefined;
readonly autoNavigateFirstChild?: boolean | undefined;
readonly items?: unknown[] | undefined;
};
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        top?(_: {
            class: string;
        }): any;
        bottom?(_: {
            class: string;
        }): any;
    };
});

export declare const unnnicSidebar: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
    $emit: (event: "navigate", ...args: any[]) => void;
    width: string;
    active: Record<string, any>;
    position: string;
    autoNavigateFirstChild: boolean;
    items: unknown[];
    $props: {
    readonly width?: string | undefined;
    readonly active?: Record<string, any> | undefined;
    readonly position?: string | undefined;
    readonly autoNavigateFirstChild?: boolean | undefined;
    readonly items?: unknown[] | undefined;
    };
    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{}> & Readonly<{}>, {
    $emit: (event: "navigate", ...args: any[]) => void;
    width: string;
    active: Record<string, any>;
    position: string;
    autoNavigateFirstChild: boolean;
    items: unknown[];
    $props: {
    readonly width?: string | undefined;
    readonly active?: Record<string, any> | undefined;
    readonly position?: string | undefined;
    readonly autoNavigateFirstChild?: boolean | undefined;
    readonly items?: unknown[] | undefined;
    };
    }, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
$emit: (event: "navigate", ...args: any[]) => void;
width: string;
active: Record<string, any>;
position: string;
autoNavigateFirstChild: boolean;
items: unknown[];
$props: {
readonly width?: string | undefined;
readonly active?: Record<string, any> | undefined;
readonly position?: string | undefined;
readonly autoNavigateFirstChild?: boolean | undefined;
readonly items?: unknown[] | undefined;
};
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        top?(_: {
            class: string;
        }): any;
        bottom?(_: {
            class: string;
        }): any;
    };
});

export declare const UnnnicSidebarItem: DefineComponent<    {}, {
$emit: (event: "navigate", ...args: any[]) => void;
active: Record<string, any>;
item: Record<string, any>;
autoNavigateFirstChild: boolean;
$props: {
readonly active?: Record<string, any> | undefined;
readonly item?: Record<string, any> | undefined;
readonly autoNavigateFirstChild?: boolean | undefined;
};
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicSidebarItem: DefineComponent<    {}, {
$emit: (event: "navigate", ...args: any[]) => void;
active: Record<string, any>;
item: Record<string, any>;
autoNavigateFirstChild: boolean;
$props: {
readonly active?: Record<string, any> | undefined;
readonly item?: Record<string, any> | undefined;
readonly autoNavigateFirstChild?: boolean | undefined;
};
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicSimpleCard: DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: string;
};
titleSize: {
type: StringConstructor;
default: string;
};
titleTooltip: {
type: StringConstructor;
default: string;
};
text: {
type: StringConstructor;
default: string;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "click"[], "click", PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: string;
};
titleSize: {
type: StringConstructor;
default: string;
};
titleTooltip: {
type: StringConstructor;
default: string;
};
text: {
type: StringConstructor;
default: string;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onClick?: ((...args: any[]) => any) | undefined;
}>, {
title: string;
text: string;
clickable: boolean;
titleSize: string;
titleTooltip: string;
}, {}, {
UnnnicToolTip: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, PublicProps, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, string, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicSimpleCard: DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: string;
};
titleSize: {
type: StringConstructor;
default: string;
};
titleTooltip: {
type: StringConstructor;
default: string;
};
text: {
type: StringConstructor;
default: string;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "click"[], "click", PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: string;
};
titleSize: {
type: StringConstructor;
default: string;
};
titleTooltip: {
type: StringConstructor;
default: string;
};
text: {
type: StringConstructor;
default: string;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onClick?: ((...args: any[]) => any) | undefined;
}>, {
title: string;
text: string;
clickable: boolean;
titleSize: string;
titleTooltip: string;
}, {}, {
UnnnicToolTip: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, PublicProps, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, string, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicSkeletonLoading: DefineComponent<SkeletonLoadingProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SkeletonLoadingProps> & Readonly<{}>, {
circle: boolean;
width: string | number;
height: string | number;
loading: boolean;
count: number;
prefix: string;
duration: number;
tag: string;
direct: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const unnnicSkeletonLoading: DefineComponent<SkeletonLoadingProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SkeletonLoadingProps> & Readonly<{}>, {
circle: boolean;
width: string | number;
height: string | number;
loading: boolean;
count: number;
prefix: string;
duration: number;
tag: string;
direct: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const UnnnicSwitch: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<SwitchProps> & Readonly<{
    "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:model-value": (...args: any[]) => void;
    }, PublicProps, {
    disabled: boolean;
    label: string;
    option: string;
    size: "small" | "medium";
    modelValue: boolean;
    helper: string;
    textRight: string;
    labelTooltip: TooltipProps;
    textLeft: string;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<SwitchProps> & Readonly<{
    "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
    }>, {}, {}, {}, {}, {
    disabled: boolean;
    label: string;
    option: string;
    size: "small" | "medium";
    modelValue: boolean;
    helper: string;
    textRight: string;
    labelTooltip: TooltipProps;
    textLeft: string;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<SwitchProps> & Readonly<{
"onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:model-value": (...args: any[]) => void;
}, string, {
disabled: boolean;
label: string;
option: string;
size: "small" | "medium";
modelValue: boolean;
helper: string;
textRight: string;
labelTooltip: TooltipProps;
textLeft: string;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        suffix?(_: {}): any;
    };
});

export declare const unnnicSwitch: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<SwitchProps> & Readonly<{
    "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:model-value": (...args: any[]) => void;
    }, PublicProps, {
    disabled: boolean;
    label: string;
    option: string;
    size: "small" | "medium";
    modelValue: boolean;
    helper: string;
    textRight: string;
    labelTooltip: TooltipProps;
    textLeft: string;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<SwitchProps> & Readonly<{
    "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
    }>, {}, {}, {}, {}, {
    disabled: boolean;
    label: string;
    option: string;
    size: "small" | "medium";
    modelValue: boolean;
    helper: string;
    textRight: string;
    labelTooltip: TooltipProps;
    textLeft: string;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<SwitchProps> & Readonly<{
"onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:model-value": (...args: any[]) => void;
}, string, {
disabled: boolean;
label: string;
option: string;
size: "small" | "medium";
modelValue: boolean;
helper: string;
textRight: string;
labelTooltip: TooltipProps;
textLeft: string;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        suffix?(_: {}): any;
    };
});

export declare const UnnnicTab: DefineComponent<ExtractPropTypes<    {
size: {
type: StringConstructor;
default: string;
validator: (size: unknown) => boolean;
};
activeTab: {
type: StringConstructor;
default: string;
};
initialTab: {
type: StringConstructor;
default: null;
};
tabs: {
type: ArrayConstructor;
default: null;
validator: (tabs: unknown) => any;
};
disabledTabs: {
type: ArrayConstructor;
default: null;
};
}>, {}, {
localValue: string;
}, {
tabPanelSlotName(): string;
}, {
tabHeadSlotName(tabName: any): string;
tabHeadTooltipSlotName(tabName: any): string;
getHeadTooltip(tabName: any): VNodeNormalizedChildren;
change(value: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, "change"[], "change", PublicProps, Readonly<ExtractPropTypes<    {
size: {
type: StringConstructor;
default: string;
validator: (size: unknown) => boolean;
};
activeTab: {
type: StringConstructor;
default: string;
};
initialTab: {
type: StringConstructor;
default: null;
};
tabs: {
type: ArrayConstructor;
default: null;
validator: (tabs: unknown) => any;
};
disabledTabs: {
type: ArrayConstructor;
default: null;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
}>, {
size: string;
activeTab: string;
initialTab: string;
tabs: unknown[];
disabledTabs: unknown[];
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
UnnnicToolTip: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, PublicProps, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, string, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicTab: DefineComponent<ExtractPropTypes<    {
size: {
type: StringConstructor;
default: string;
validator: (size: unknown) => boolean;
};
activeTab: {
type: StringConstructor;
default: string;
};
initialTab: {
type: StringConstructor;
default: null;
};
tabs: {
type: ArrayConstructor;
default: null;
validator: (tabs: unknown) => any;
};
disabledTabs: {
type: ArrayConstructor;
default: null;
};
}>, {}, {
localValue: string;
}, {
tabPanelSlotName(): string;
}, {
tabHeadSlotName(tabName: any): string;
tabHeadTooltipSlotName(tabName: any): string;
getHeadTooltip(tabName: any): VNodeNormalizedChildren;
change(value: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, "change"[], "change", PublicProps, Readonly<ExtractPropTypes<    {
size: {
type: StringConstructor;
default: string;
validator: (size: unknown) => boolean;
};
activeTab: {
type: StringConstructor;
default: string;
};
initialTab: {
type: StringConstructor;
default: null;
};
tabs: {
type: ArrayConstructor;
default: null;
validator: (tabs: unknown) => any;
};
disabledTabs: {
type: ArrayConstructor;
default: null;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
}>, {
size: string;
activeTab: string;
initialTab: string;
tabs: unknown[];
disabledTabs: unknown[];
}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
UnnnicToolTip: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, PublicProps, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, string, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicTable: DefineComponent<ExtractPropTypes<    {
items: {
type: ArrayConstructor;
};
version: {
type: StringConstructor;
default: string;
};
}>, {}, {
value: boolean;
}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
items: {
type: ArrayConstructor;
};
version: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
version: string;
}, {}, {
UiTable: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLDivElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, {}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, () => {
unnnicTableVersion: ComputedRef<string>;
}, true, {}, any>;

export declare const unnnicTable: DefineComponent<ExtractPropTypes<    {
items: {
type: ArrayConstructor;
};
version: {
type: StringConstructor;
default: string;
};
}>, {}, {
value: boolean;
}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
items: {
type: ArrayConstructor;
};
version: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
version: string;
}, {}, {
UiTable: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLDivElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, {}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, () => {
unnnicTableVersion: ComputedRef<string>;
}, true, {}, any>;

export declare const UnnnicTableBody: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLTableSectionElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicTableBody: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLTableSectionElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicTableCell: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
    class?: HTMLAttributes["class"];
    ellipsis?: boolean;
    width?: string;
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    ellipsis: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLTableCellElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{
    class?: HTMLAttributes["class"];
    ellipsis?: boolean;
    width?: string;
    }> & Readonly<{}>, {}, {}, {}, {}, {
    ellipsis: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
ellipsis?: boolean;
width?: string;
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
ellipsis: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicTableCell: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
    class?: HTMLAttributes["class"];
    ellipsis?: boolean;
    width?: string;
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    ellipsis: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLTableCellElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{
    class?: HTMLAttributes["class"];
    ellipsis?: boolean;
    width?: string;
    }> & Readonly<{}>, {}, {}, {}, {}, {
    ellipsis: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
ellipsis?: boolean;
width?: string;
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
ellipsis: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicTableHead: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
    class?: HTMLAttributes["class"];
    ellipsis?: boolean;
    width?: string;
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    ellipsis: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLTableCellElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{
    class?: HTMLAttributes["class"];
    ellipsis?: boolean;
    width?: string;
    }> & Readonly<{}>, {}, {}, {}, {}, {
    ellipsis: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
ellipsis?: boolean;
width?: string;
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
ellipsis: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicTableHead: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
    class?: HTMLAttributes["class"];
    ellipsis?: boolean;
    width?: string;
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    ellipsis: boolean;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLTableCellElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{
    class?: HTMLAttributes["class"];
    ellipsis?: boolean;
    width?: string;
    }> & Readonly<{}>, {}, {}, {}, {}, {
    ellipsis: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
ellipsis?: boolean;
width?: string;
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
ellipsis: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicTableHeader: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLTableSectionElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicTableHeader: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLTableSectionElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<{
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicTableNext: DefineSetupFnComponent<Record<string, any>, {}, {}, Record<string, any> & {}, PublicProps>;

export declare const unnnicTableNext: DefineSetupFnComponent<Record<string, any>, {}, {}, Record<string, any> & {}, PublicProps>;

export declare const UnnnicTableRow: DefineComponent<ExtractPropTypes<    {
headers: {
type: ArrayConstructor;
};
}>, {
isVersion2: ComputedRef<boolean>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
headers: {
type: ArrayConstructor;
};
}>> & Readonly<{}>, {}, {}, {
UiTableRow: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
class?: HTMLAttributes["class"];
}> & Readonly<{
onClick?: ((event: KeyboardEvent | MouseEvent) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
click: (event: KeyboardEvent | MouseEvent) => any;
}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLTableRowElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{
class?: HTMLAttributes["class"];
}> & Readonly<{
onClick?: ((event: KeyboardEvent | MouseEvent) => any) | undefined;
}>, {}, {}, {}, {}, {}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
}> & Readonly<{
onClick?: ((event: KeyboardEvent | MouseEvent) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
click: (event: KeyboardEvent | MouseEvent) => any;
}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicTableRow: DefineComponent<ExtractPropTypes<    {
headers: {
type: ArrayConstructor;
};
}>, {
isVersion2: ComputedRef<boolean>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
headers: {
type: ArrayConstructor;
};
}>> & Readonly<{}>, {}, {}, {
UiTableRow: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
class?: HTMLAttributes["class"];
}> & Readonly<{
onClick?: ((event: KeyboardEvent | MouseEvent) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
click: (event: KeyboardEvent | MouseEvent) => any;
}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLTableRowElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{
class?: HTMLAttributes["class"];
}> & Readonly<{
onClick?: ((event: KeyboardEvent | MouseEvent) => any) | undefined;
}>, {}, {}, {}, {}, {}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<{
class?: HTMLAttributes["class"];
}> & Readonly<{
onClick?: ((event: KeyboardEvent | MouseEvent) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
click: (event: KeyboardEvent | MouseEvent) => any;
}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicTabs: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TabsRootProps<string | number>> & Readonly<{
    "onUpdate:modelValue"?: ((payload: string | number) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:modelValue": (payload: string | number) => any;
    }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<TabsRootProps<string | number>> & Readonly<{
    "onUpdate:modelValue"?: ((payload: string | number) => any) | undefined;
    }>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<TabsRootProps<string | number>> & Readonly<{
"onUpdate:modelValue"?: ((payload: string | number) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (payload: string | number) => any;
}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicTabs: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TabsRootProps<string | number>> & Readonly<{
    "onUpdate:modelValue"?: ((payload: string | number) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:modelValue": (payload: string | number) => any;
    }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<TabsRootProps<string | number>> & Readonly<{
    "onUpdate:modelValue"?: ((payload: string | number) => any) | undefined;
    }>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<TabsRootProps<string | number>> & Readonly<{
"onUpdate:modelValue"?: ((payload: string | number) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (payload: string | number) => any;
}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicTabsContent: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TabsContentProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<TabsContentProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<TabsContentProps & {
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicTabsContent: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TabsContentProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<TabsContentProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<TabsContentProps & {
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicTabsExpanded: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: (StringConstructor | NumberConstructor)[];
required: true;
};
items: {
type: ArrayConstructor;
required: true;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("add" | "update:model-value" | "back" | "close-tab")[], "add" | "update:model-value" | "back" | "close-tab", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: (StringConstructor | NumberConstructor)[];
required: true;
};
items: {
type: ArrayConstructor;
required: true;
};
}>> & Readonly<{
"onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
onAdd?: ((...args: any[]) => any) | undefined;
onBack?: ((...args: any[]) => any) | undefined;
"onClose-tab"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicTabsExpanded: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: (StringConstructor | NumberConstructor)[];
required: true;
};
items: {
type: ArrayConstructor;
required: true;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("add" | "update:model-value" | "back" | "close-tab")[], "add" | "update:model-value" | "back" | "close-tab", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: (StringConstructor | NumberConstructor)[];
required: true;
};
items: {
type: ArrayConstructor;
required: true;
};
}>> & Readonly<{
"onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
onAdd?: ((...args: any[]) => any) | undefined;
onBack?: ((...args: any[]) => any) | undefined;
"onClose-tab"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicTabsList: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TabsListProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<TabsListProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<TabsListProps & {
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
        right?(_: {}): any;
    };
});

export declare const unnnicTabsList: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TabsListProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<TabsListProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<TabsListProps & {
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
        right?(_: {}): any;
    };
});

export declare const UnnnicTabsTrigger: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TabsTriggerProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<TabsTriggerProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<TabsTriggerProps & {
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicTabsTrigger: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TabsTriggerProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<TabsTriggerProps & {
    class?: HTMLAttributes["class"];
    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<TabsTriggerProps & {
class?: HTMLAttributes["class"];
}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicTag: DefineComponent<TagProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: () => any;
close: () => any;
}, string, PublicProps, Readonly<TagProps> & Readonly<{
onClick?: (() => any) | undefined;
onClose?: (() => any) | undefined;
}>, {
disabled: boolean;
type: TagType;
text: string;
size: TagSize;
scheme: string;
leftIcon: string;
hasCloseIcon: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const unnnicTag: DefineComponent<TagProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: () => any;
close: () => any;
}, string, PublicProps, Readonly<TagProps> & Readonly<{
onClick?: (() => any) | undefined;
onClose?: (() => any) | undefined;
}>, {
disabled: boolean;
type: TagType;
text: string;
size: TagSize;
scheme: string;
leftIcon: string;
hasCloseIcon: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const UnnnicTemplatePreview: VueComponent;

export declare const unnnicTemplatePreview: VueComponent;

export declare const UnnnicTemplatePreviewModal: VueComponent;

export declare const unnnicTemplatePreviewModal: VueComponent;

export declare const UnnnicTextArea: DefineComponent<TextAreaProps, {
focus: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (...args: any[]) => void;
}, string, PublicProps, Readonly<TextAreaProps> & Readonly<{
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
disabled: boolean;
resize: "none" | "vertical";
type: "normal" | "error";
placeholder: string;
label: string;
size: "md" | "sm";
tooltip: TooltipProps;
message: string;
modelValue: string;
errors: string | string[];
maxLength: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
textareaRef: HTMLTextAreaElement;
}, HTMLElement>;

export declare const unnnicTextArea: DefineComponent<TextAreaProps, {
focus: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (...args: any[]) => void;
}, string, PublicProps, Readonly<TextAreaProps> & Readonly<{
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
disabled: boolean;
resize: "none" | "vertical";
type: "normal" | "error";
placeholder: string;
label: string;
size: "md" | "sm";
tooltip: TooltipProps;
message: string;
modelValue: string;
errors: string | string[];
maxLength: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
textareaRef: HTMLTextAreaElement;
}, HTMLElement>;

export declare const UnnnicToast: DefineComponent<ToastProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
close: () => any;
destroy: () => any;
}, string, PublicProps, Readonly<ToastProps> & Readonly<{
onClose?: (() => any) | undefined;
onDestroy?: (() => any) | undefined;
}>, {
type: ToastType;
button: ToastButton;
title: string;
description: string;
timeout: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const unnnicToast: DefineComponent<ToastProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
close: () => any;
destroy: () => any;
}, string, PublicProps, Readonly<ToastProps> & Readonly<{
onClose?: (() => any) | undefined;
onDestroy?: (() => any) | undefined;
}>, {
type: ToastType;
button: ToastButton;
title: string;
description: string;
timeout: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const UnnnicToastManager: ToastCall;

export declare const unnnicToastManager: ToastCall;

export declare const UnnnicToolTip: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TooltipProps> & Readonly<{
    "onClick:close"?: ((...args: any[]) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "click:close": (...args: any[]) => void;
    }, PublicProps, {
    text: string;
    class: string;
    side: "top" | "right" | "bottom" | "left";
    enabled: boolean;
    forceOpen: boolean;
    maxWidth: string;
    enableHtml: boolean;
    showClose: boolean;
    contentProps: Partial<TooltipContentProps>;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<TooltipProps> & Readonly<{
    "onClick:close"?: ((...args: any[]) => any) | undefined;
    }>, {}, {}, {}, {}, {
    text: string;
    class: string;
    side: "top" | "right" | "bottom" | "left";
    enabled: boolean;
    forceOpen: boolean;
    maxWidth: string;
    enableHtml: boolean;
    showClose: boolean;
    contentProps: Partial<TooltipContentProps>;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, string, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const unnnicToolTip: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<TooltipProps> & Readonly<{
    "onClick:close"?: ((...args: any[]) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "click:close": (...args: any[]) => void;
    }, PublicProps, {
    text: string;
    class: string;
    side: "top" | "right" | "bottom" | "left";
    enabled: boolean;
    forceOpen: boolean;
    maxWidth: string;
    enableHtml: boolean;
    showClose: boolean;
    contentProps: Partial<TooltipContentProps>;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<TooltipProps> & Readonly<{
    "onClick:close"?: ((...args: any[]) => any) | undefined;
    }>, {}, {}, {}, {}, {
    text: string;
    class: string;
    side: "top" | "right" | "bottom" | "left";
    enabled: boolean;
    forceOpen: boolean;
    maxWidth: string;
    enableHtml: boolean;
    showClose: boolean;
    contentProps: Partial<TooltipContentProps>;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<TooltipProps> & Readonly<{
"onClick:close"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click:close": (...args: any[]) => void;
}, string, {
text: string;
class: string;
side: "top" | "right" | "bottom" | "left";
enabled: boolean;
forceOpen: boolean;
maxWidth: string;
enableHtml: boolean;
showClose: boolean;
contentProps: Partial<TooltipContentProps>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        default?(_: {}): any;
    };
});

export declare const UnnnicTour: DefineComponent<ExtractPropTypes<    {
steps: {
required: true;
type: ArrayConstructor;
validator: (steps: any) => boolean;
};
}>, {}, {
isTourActive: boolean;
currentStep: number;
maskRect: {
x: number;
y: number;
width: number;
height: number;
};
}, {
currentStepOptions(): unknown;
stepStyle(): {
top?: undefined;
left?: undefined;
width?: undefined;
height?: undefined;
} | {
top: string;
left: string;
width: string;
height: string;
};
}, {
start(): void;
end(): void;
close(): void;
handleStep(step: any): Promise<void>;
nextStep(): void;
updateMaskRect(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "nextStep" | "endTour")[], "close" | "nextStep" | "endTour", PublicProps, Readonly<ExtractPropTypes<    {
steps: {
required: true;
type: ArrayConstructor;
validator: (steps: any) => boolean;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
onNextStep?: ((...args: any[]) => any) | undefined;
onEndTour?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {
TourMask: DefineComponent<ExtractPropTypes<    {
maskRect: {
type: ObjectConstructor;
required: true;
};
}>, {}, {}, {
clickBlockerRects(): ({
x: string;
y: string;
width: string;
height: any;
style?: undefined;
} | {
x: string;
y: string;
width: any;
height: string;
style?: undefined;
} | {
x: string;
y: any;
style: {
height: string;
width?: undefined;
};
width: string;
height?: undefined;
} | {
x: any;
y: string;
style: {
width: string;
height?: undefined;
};
height: string;
width?: undefined;
})[];
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
maskRect: {
type: ObjectConstructor;
required: true;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
TourPopover: DefineComponent<ExtractPropTypes<    {
step: {
type: ObjectConstructor;
required: true;
};
currentStep: {
type: NumberConstructor;
required: true;
};
stepsLength: {
type: NumberConstructor;
required: true;
};
attachedElement: {
type: {
new (): Element;
prototype: Element;
};
required: true;
};
}>, {}, {
style: {};
defaultTranslations: {
close_tour: {
'pt-br': string;
en: string;
es: string;
};
understood: {
'pt-br': string;
en: string;
es: string;
};
};
}, {}, {
updatePopoverStyle(): void;
}, {
props: {
locale: {
type: StringConstructor;
};
translations: {
type: ObjectConstructor;
};
};
methods: {
i18n(...args: any[]): any;
};
}, ComponentOptionsMixin, ("close" | "end" | "nextStep")[], "close" | "end" | "nextStep", PublicProps, Readonly<ExtractPropTypes<    {
step: {
type: ObjectConstructor;
required: true;
};
currentStep: {
type: NumberConstructor;
required: true;
};
stepsLength: {
type: NumberConstructor;
required: true;
};
attachedElement: {
type: {
new (): Element;
prototype: Element;
};
required: true;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
onEnd?: ((...args: any[]) => any) | undefined;
onNextStep?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {
UnnnicButton: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLButtonElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, ComponentProvideOptions, true, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicTour: DefineComponent<ExtractPropTypes<    {
steps: {
required: true;
type: ArrayConstructor;
validator: (steps: any) => boolean;
};
}>, {}, {
isTourActive: boolean;
currentStep: number;
maskRect: {
x: number;
y: number;
width: number;
height: number;
};
}, {
currentStepOptions(): unknown;
stepStyle(): {
top?: undefined;
left?: undefined;
width?: undefined;
height?: undefined;
} | {
top: string;
left: string;
width: string;
height: string;
};
}, {
start(): void;
end(): void;
close(): void;
handleStep(step: any): Promise<void>;
nextStep(): void;
updateMaskRect(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "nextStep" | "endTour")[], "close" | "nextStep" | "endTour", PublicProps, Readonly<ExtractPropTypes<    {
steps: {
required: true;
type: ArrayConstructor;
validator: (steps: any) => boolean;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
onNextStep?: ((...args: any[]) => any) | undefined;
onEndTour?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {
TourMask: DefineComponent<ExtractPropTypes<    {
maskRect: {
type: ObjectConstructor;
required: true;
};
}>, {}, {}, {
clickBlockerRects(): ({
x: string;
y: string;
width: string;
height: any;
style?: undefined;
} | {
x: string;
y: string;
width: any;
height: string;
style?: undefined;
} | {
x: string;
y: any;
style: {
height: string;
width?: undefined;
};
width: string;
height?: undefined;
} | {
x: any;
y: string;
style: {
width: string;
height?: undefined;
};
height: string;
width?: undefined;
})[];
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
maskRect: {
type: ObjectConstructor;
required: true;
};
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
TourPopover: DefineComponent<ExtractPropTypes<    {
step: {
type: ObjectConstructor;
required: true;
};
currentStep: {
type: NumberConstructor;
required: true;
};
stepsLength: {
type: NumberConstructor;
required: true;
};
attachedElement: {
type: {
new (): Element;
prototype: Element;
};
required: true;
};
}>, {}, {
style: {};
defaultTranslations: {
close_tour: {
'pt-br': string;
en: string;
es: string;
};
understood: {
'pt-br': string;
en: string;
es: string;
};
};
}, {}, {
updatePopoverStyle(): void;
}, {
props: {
locale: {
type: StringConstructor;
};
translations: {
type: ObjectConstructor;
};
};
methods: {
i18n(...args: any[]): any;
};
}, ComponentOptionsMixin, ("close" | "end" | "nextStep")[], "close" | "end" | "nextStep", PublicProps, Readonly<ExtractPropTypes<    {
step: {
type: ObjectConstructor;
required: true;
};
currentStep: {
type: NumberConstructor;
required: true;
};
stepsLength: {
type: NumberConstructor;
required: true;
};
attachedElement: {
type: {
new (): Element;
prototype: Element;
};
required: true;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
onEnd?: ((...args: any[]) => any) | undefined;
onNextStep?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {
UnnnicButton: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLButtonElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
}, {}, string, ComponentProvideOptions, true, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const UnnnicUploadArea: DefineComponent<ExtractPropTypes<    {
files: {
type: ArrayConstructor;
default: () => never[];
};
acceptMultiple: {
type: BooleanConstructor;
default: boolean;
};
supportedFormats: {
type: StringConstructor;
default: string;
};
maximumUploads: {
type: NumberConstructor;
default: number;
};
filesProgress: {
type: ArrayConstructor;
default: () => never[];
};
isUploading: {
type: BooleanConstructor;
default: boolean;
};
canImport: {
type: BooleanConstructor;
default: boolean;
};
canDelete: {
type: BooleanConstructor;
default: boolean;
};
maxFileSize: {
type: NumberConstructor;
default: undefined;
};
shouldReplace: {
type: BooleanConstructor;
default: boolean;
};
subtitle: {
required: false;
type: StringConstructor;
default: string;
};
}>, {}, {
currentFiles: unknown[];
}, {}, {
emitFileChange(): void;
modifyFile(index: any, file: any): void;
removeFile(index: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, "fileChange"[], "fileChange", PublicProps, Readonly<ExtractPropTypes<    {
files: {
type: ArrayConstructor;
default: () => never[];
};
acceptMultiple: {
type: BooleanConstructor;
default: boolean;
};
supportedFormats: {
type: StringConstructor;
default: string;
};
maximumUploads: {
type: NumberConstructor;
default: number;
};
filesProgress: {
type: ArrayConstructor;
default: () => never[];
};
isUploading: {
type: BooleanConstructor;
default: boolean;
};
canImport: {
type: BooleanConstructor;
default: boolean;
};
canDelete: {
type: BooleanConstructor;
default: boolean;
};
maxFileSize: {
type: NumberConstructor;
default: undefined;
};
shouldReplace: {
type: BooleanConstructor;
default: boolean;
};
subtitle: {
required: false;
type: StringConstructor;
default: string;
};
}>> & Readonly<{
onFileChange?: ((...args: any[]) => any) | undefined;
}>, {
subtitle: string;
acceptMultiple: boolean;
supportedFormats: string;
maxFileSize: number;
shouldReplace: boolean;
maximumUploads: number;
canImport: boolean;
canDelete: boolean;
files: unknown[];
filesProgress: unknown[];
isUploading: boolean;
}, {}, {
UnnnicDropArea: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
$emit: (event: "update:currentFiles" | "fileChange" | "unsupportedFormat" | "exceededTheMaximumFileSizeLimit", ...args: any[]) => void;
disabled: boolean;
subtitle: string;
acceptMultiple: boolean;
supportedFormats: string;
shouldReplace: boolean;
currentFiles: unknown[];
maximumUploads: number;
maxFileSize?: number | undefined;
$props: {
readonly disabled?: boolean | undefined;
readonly subtitle?: string | undefined;
readonly acceptMultiple?: boolean | undefined;
readonly supportedFormats?: string | undefined;
readonly shouldReplace?: boolean | undefined;
readonly currentFiles?: unknown[] | undefined;
readonly maximumUploads?: number | undefined;
readonly maxFileSize?: number | undefined;
};
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {
dropzone: HTMLElement;
file: HTMLInputElement;
}, HTMLElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{}> & Readonly<{}>, {
$emit: (event: "update:currentFiles" | "fileChange" | "unsupportedFormat" | "exceededTheMaximumFileSizeLimit", ...args: any[]) => void;
disabled: boolean;
subtitle: string;
acceptMultiple: boolean;
supportedFormats: string;
shouldReplace: boolean;
currentFiles: unknown[];
maximumUploads: number;
maxFileSize?: number | undefined;
$props: {
readonly disabled?: boolean | undefined;
readonly subtitle?: string | undefined;
readonly acceptMultiple?: boolean | undefined;
readonly supportedFormats?: string | undefined;
readonly shouldReplace?: boolean | undefined;
readonly currentFiles?: unknown[] | undefined;
readonly maximumUploads?: number | undefined;
readonly maxFileSize?: number | undefined;
};
}, {}, {}, {}, {}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
$emit: (event: "update:currentFiles" | "fileChange" | "unsupportedFormat" | "exceededTheMaximumFileSizeLimit", ...args: any[]) => void;
disabled: boolean;
subtitle: string;
acceptMultiple: boolean;
supportedFormats: string;
shouldReplace: boolean;
currentFiles: unknown[];
maximumUploads: number;
maxFileSize?: number | undefined;
$props: {
readonly disabled?: boolean | undefined;
readonly subtitle?: string | undefined;
readonly acceptMultiple?: boolean | undefined;
readonly supportedFormats?: string | undefined;
readonly shouldReplace?: boolean | undefined;
readonly currentFiles?: unknown[] | undefined;
readonly maximumUploads?: number | undefined;
readonly maxFileSize?: number | undefined;
};
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
title?(_: {}): any;
subtitle?(_: {}): any;
};
});
UnnnicImportCard: DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: string;
};
subtitle: {
type: StringConstructor;
default: string;
};
importProgress: {
type: NumberConstructor;
default: number;
};
isImporting: {
type: BooleanConstructor;
default: boolean;
};
canImport: {
type: BooleanConstructor;
default: boolean;
};
canDelete: {
type: BooleanConstructor;
default: boolean;
};
acceptedFormats: {
type: StringConstructor;
default: string;
};
uploadIcon: {
type: StringConstructor;
default: string;
};
}>, {}, {}, {
fileIcon(): any;
}, {
importFile(): void;
handleFileChange(event: any): void;
emitDeletion(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: string;
};
subtitle: {
type: StringConstructor;
default: string;
};
importProgress: {
type: NumberConstructor;
default: number;
};
isImporting: {
type: BooleanConstructor;
default: boolean;
};
canImport: {
type: BooleanConstructor;
default: boolean;
};
canDelete: {
type: BooleanConstructor;
default: boolean;
};
acceptedFormats: {
type: StringConstructor;
default: string;
};
uploadIcon: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
title: string;
subtitle: string;
importProgress: number;
isImporting: boolean;
canImport: boolean;
canDelete: boolean;
acceptedFormats: string;
uploadIcon: string;
}, {}, {
UnnnicButton: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLButtonElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const unnnicUploadArea: DefineComponent<ExtractPropTypes<    {
files: {
type: ArrayConstructor;
default: () => never[];
};
acceptMultiple: {
type: BooleanConstructor;
default: boolean;
};
supportedFormats: {
type: StringConstructor;
default: string;
};
maximumUploads: {
type: NumberConstructor;
default: number;
};
filesProgress: {
type: ArrayConstructor;
default: () => never[];
};
isUploading: {
type: BooleanConstructor;
default: boolean;
};
canImport: {
type: BooleanConstructor;
default: boolean;
};
canDelete: {
type: BooleanConstructor;
default: boolean;
};
maxFileSize: {
type: NumberConstructor;
default: undefined;
};
shouldReplace: {
type: BooleanConstructor;
default: boolean;
};
subtitle: {
required: false;
type: StringConstructor;
default: string;
};
}>, {}, {
currentFiles: unknown[];
}, {}, {
emitFileChange(): void;
modifyFile(index: any, file: any): void;
removeFile(index: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, "fileChange"[], "fileChange", PublicProps, Readonly<ExtractPropTypes<    {
files: {
type: ArrayConstructor;
default: () => never[];
};
acceptMultiple: {
type: BooleanConstructor;
default: boolean;
};
supportedFormats: {
type: StringConstructor;
default: string;
};
maximumUploads: {
type: NumberConstructor;
default: number;
};
filesProgress: {
type: ArrayConstructor;
default: () => never[];
};
isUploading: {
type: BooleanConstructor;
default: boolean;
};
canImport: {
type: BooleanConstructor;
default: boolean;
};
canDelete: {
type: BooleanConstructor;
default: boolean;
};
maxFileSize: {
type: NumberConstructor;
default: undefined;
};
shouldReplace: {
type: BooleanConstructor;
default: boolean;
};
subtitle: {
required: false;
type: StringConstructor;
default: string;
};
}>> & Readonly<{
onFileChange?: ((...args: any[]) => any) | undefined;
}>, {
subtitle: string;
acceptMultiple: boolean;
supportedFormats: string;
maxFileSize: number;
shouldReplace: boolean;
maximumUploads: number;
canImport: boolean;
canDelete: boolean;
files: unknown[];
filesProgress: unknown[];
isUploading: boolean;
}, {}, {
UnnnicDropArea: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
$emit: (event: "update:currentFiles" | "fileChange" | "unsupportedFormat" | "exceededTheMaximumFileSizeLimit", ...args: any[]) => void;
disabled: boolean;
subtitle: string;
acceptMultiple: boolean;
supportedFormats: string;
shouldReplace: boolean;
currentFiles: unknown[];
maximumUploads: number;
maxFileSize?: number | undefined;
$props: {
readonly disabled?: boolean | undefined;
readonly subtitle?: string | undefined;
readonly acceptMultiple?: boolean | undefined;
readonly supportedFormats?: string | undefined;
readonly shouldReplace?: boolean | undefined;
readonly currentFiles?: unknown[] | undefined;
readonly maximumUploads?: number | undefined;
readonly maxFileSize?: number | undefined;
};
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {
dropzone: HTMLElement;
file: HTMLInputElement;
}, HTMLElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{}> & Readonly<{}>, {
$emit: (event: "update:currentFiles" | "fileChange" | "unsupportedFormat" | "exceededTheMaximumFileSizeLimit", ...args: any[]) => void;
disabled: boolean;
subtitle: string;
acceptMultiple: boolean;
supportedFormats: string;
shouldReplace: boolean;
currentFiles: unknown[];
maximumUploads: number;
maxFileSize?: number | undefined;
$props: {
readonly disabled?: boolean | undefined;
readonly subtitle?: string | undefined;
readonly acceptMultiple?: boolean | undefined;
readonly supportedFormats?: string | undefined;
readonly shouldReplace?: boolean | undefined;
readonly currentFiles?: unknown[] | undefined;
readonly maximumUploads?: number | undefined;
readonly maxFileSize?: number | undefined;
};
}, {}, {}, {}, {}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
$emit: (event: "update:currentFiles" | "fileChange" | "unsupportedFormat" | "exceededTheMaximumFileSizeLimit", ...args: any[]) => void;
disabled: boolean;
subtitle: string;
acceptMultiple: boolean;
supportedFormats: string;
shouldReplace: boolean;
currentFiles: unknown[];
maximumUploads: number;
maxFileSize?: number | undefined;
$props: {
readonly disabled?: boolean | undefined;
readonly subtitle?: string | undefined;
readonly acceptMultiple?: boolean | undefined;
readonly supportedFormats?: string | undefined;
readonly shouldReplace?: boolean | undefined;
readonly currentFiles?: unknown[] | undefined;
readonly maximumUploads?: number | undefined;
readonly maxFileSize?: number | undefined;
};
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
title?(_: {}): any;
subtitle?(_: {}): any;
};
});
UnnnicImportCard: DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: string;
};
subtitle: {
type: StringConstructor;
default: string;
};
importProgress: {
type: NumberConstructor;
default: number;
};
isImporting: {
type: BooleanConstructor;
default: boolean;
};
canImport: {
type: BooleanConstructor;
default: boolean;
};
canDelete: {
type: BooleanConstructor;
default: boolean;
};
acceptedFormats: {
type: StringConstructor;
default: string;
};
uploadIcon: {
type: StringConstructor;
default: string;
};
}>, {}, {}, {
fileIcon(): any;
}, {
importFile(): void;
handleFileChange(event: any): void;
emitDeletion(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: string;
};
subtitle: {
type: StringConstructor;
default: string;
};
importProgress: {
type: NumberConstructor;
default: number;
};
isImporting: {
type: BooleanConstructor;
default: boolean;
};
canImport: {
type: BooleanConstructor;
default: boolean;
};
canDelete: {
type: BooleanConstructor;
default: boolean;
};
acceptedFormats: {
type: StringConstructor;
default: string;
};
uploadIcon: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
title: string;
subtitle: string;
importProgress: number;
isImporting: boolean;
canImport: boolean;
canDelete: boolean;
acceptedFormats: string;
uploadIcon: string;
}, {}, {
UnnnicButton: {
new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLButtonElement, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}>;
__isFragment?: never;
__isTeleport?: never;
__isSuspense?: never;
} & ComponentOptionsBase<Readonly<ButtonProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
disabled: boolean;
type: ButtonType;
text: string;
size: ButtonSize;
iconLeft: string;
iconRight: string;
float: boolean;
iconCenter: string;
iconsFilled: boolean;
loading: boolean;
pressed: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
$slots: {
default?(_: {}): any;
};
});
UnnnicIcon: DefineComponent<IconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: Event) => any;
mousedown: (event: Event) => any;
mouseup: (event: Event) => any;
}, string, PublicProps, Readonly<IconProps> & Readonly<{
onClick?: ((event: Event) => any) | undefined;
onMousedown?: ((event: Event) => any) | undefined;
onMouseup?: ((event: Event) => any) | undefined;
}>, {
size: IconSize;
filled: boolean;
icon: string | null;
clickable: boolean;
scheme: SchemeColor;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;
}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare function useTheme(): {
    preference: Ref<ThemePreference, ThemePreference>;
    resolvedTheme: ComputedRef<Theme>;
    setTheme: (value: ThemePreference) => void;
    toggleTheme: () => void;
};

declare type VueComponent = Component;

export { }