buefy/dist/buefy.d.ts

Lightweight UI components for Vue.js (v3) based on Bulma

import { AllowedComponentProps } from 'vue';
import type { App } from 'vue';
import { BuefyConfig as BuefyConfig_2 } from './config';
import { ComponentCustomProps } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import type { ComponentPublicInstance } from 'vue';
import { CreateComponentPublicInstance } from 'vue';
import { CustomSearchFunction as CustomSearchFunction_2 } from './types';
import { DefineComponent } from 'vue';
import { ExtractPropTypes } from 'vue';
import { FieldLabelPosition as FieldLabelPosition_2 } from '../../index.ts';
import { FieldMessageProp } from '../field/Field.vue';
import { FieldMessagePropItem } from '../field/Field.vue';
import { FieldTypeProp } from '../field/Field.vue';
import { HourFormat } from '../../utils/TimepickerMixin';
import { IconPack as IconPack_2 } from '../../index.ts';
import { IMenuItem } from './MenuItemContainerMixin';
import { InjectedChildMixin } from '../../utils/InjectedChildMixin';
import { InjectedChildMixin as InjectedChildMixin_2 } from '../../utils/InjectedChildMixin.ts';
import { ITimepickerMixin } from '../../utils/TimepickerMixin';
import { ModalCancellableOption as ModalCancellableOption_2 } from '../../index.ts';
import { ModalScrollOption as ModalScrollOption_2 } from '../../index.ts';
import { NoticePosition as NoticePosition_2 } from '../../index.ts';
import { PropType } from 'vue';
import { ProviderParentMixin } from '../../utils/ProviderParentMixin';
import { ProviderParentMixin as ProviderParentMixin_2 } from '../../utils/ProviderParentMixin.ts';
import { PublicProps } from 'vue';
import { RendererElement } from 'vue';
import { RendererNode } from 'vue';
import { Slot } from 'vue';
import { Slots } from 'vue';
import { StyleValue } from 'vue';
import { StyleValue as StyleValue_3 } from './types';
import { StyleValueUnit as StyleValueUnit_2 } from './types';
import { TimeCreator } from '../../utils/TimepickerMixin';
import { TimeFormatter } from '../../utils/TimepickerMixin';
import { TimeParser } from '../../utils/TimepickerMixin';
import { TransitionName } from '../../utils/TabbedChildMixin';
import { VNode } from 'vue';
import { VNodeProps } from 'vue';
import { VueClassAttribute as VueClassAttribute_2 } from '../../index.ts';

export declare const Autocomplete: {
    install(Vue: App): void;
};

export declare const BAutocomplete: DefineComponent<    {
modelValue: PropType<number | string | null>;
data: {
type: ArrayConstructor;
default: () => never[];
};
field: {
type: StringConstructor;
default: string;
};
keepFirst: BooleanConstructor;
clearOnSelect: BooleanConstructor;
openOnFocus: BooleanConstructor;
customFormatter: {
type: PropType<(option: any) => string>;
};
checkInfiniteScroll: BooleanConstructor;
keepOpen: BooleanConstructor;
selectOnClickOutside: BooleanConstructor;
clearable: BooleanConstructor;
maxHeight: (NumberConstructor | StringConstructor)[];
dropdownPosition: {
type: StringConstructor;
default: string;
};
groupField: StringConstructor;
groupOptions: StringConstructor;
iconRight: StringConstructor;
iconRightClickable: BooleanConstructor;
appendToBody: BooleanConstructor;
type: {
type: StringConstructor;
default: string;
};
confirmKeys: {
type: ArrayConstructor;
default: () => string[];
};
selectableHeader: BooleanConstructor;
selectableFooter: BooleanConstructor;
autocomplete: StringConstructor;
}, unknown, {
selected: any;
hovered: any;
headerHovered: boolean | null;
footerHovered: boolean | null;
isActive: boolean;
newValue: string | number | null | undefined;
newAutocomplete: string;
ariaAutocomplete: string;
isListInViewportVertically: boolean;
hasFocus: boolean;
style: {};
_isAutocomplete: boolean;
_elementRef: string;
_bodyEl: Element | undefined;
timeOutID: ReturnType<typeof setTimeout> | undefined;
}, {
computedData(): DataItem[];
isEmpty(): boolean;
whiteList(): any[];
hasDefaultSlot(): boolean;
hasGroupSlot(): boolean;
hasEmptySlot(): boolean;
hasHeaderSlot(): boolean;
hasFooterSlot(): boolean;
isOpenedTop(): boolean;
newIconRight(): string | undefined;
newIconRightClickable(): boolean;
contentStyle(): {
maxHeight: string | undefined;
};
}, {
setHovered(option: any): void;
setSelected(option: any, closeDropdown?: boolean, event?: Event): void;
selectFirstOption(computedData: DataItem[]): void;
findHoveredIndex(data: any[]): number;
keydown(event: KeyboardEvent): void;
selectHeaderOrFoterByClick(event: MouseEvent, origin: "header" | "footer"): void;
checkIfHeaderOrFooterSelected(event: Event, triggerClick: {
origin: "header" | "footer";
} | null, closeDropdown?: boolean): void;
clickedOutside(event: MouseEvent): void;
getValue(option: any): any;
checkIfReachedTheEndOfScroll(): void;
calcDropdownInViewportVertical(): void;
keyArrows(direction: "down" | "up"): void;
focused(event?: Event): void;
onBlur(event: Event): void;
onInput(): void;
rightIconClick(event: MouseEvent): void;
checkValidity(): void;
updateAppendToBody(): void;
}, DefineComponent<    {
compatFallthrough: {
type: BooleanConstructor;
default: () => boolean;
};
}, unknown, unknown, {
rootAttrs(): {
class: unknown;
style: StyleValue;
id: string | undefined;
} | {
class?: undefined;
style?: undefined;
id?: undefined;
};
fallthroughAttrs(): {
[x: string]: unknown;
};
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
compatFallthrough: {
type: BooleanConstructor;
default: () => boolean;
};
}>>, {
compatFallthrough: boolean;
}, {}> | DefineComponent<    {
size: StringConstructor;
expanded: BooleanConstructor;
loading: BooleanConstructor;
rounded: BooleanConstructor;
icon: StringConstructor;
iconPack: StringConstructor;
maxlength: (NumberConstructor | StringConstructor)[];
useHtml5Validation: {
type: BooleanConstructor;
default: () => boolean;
};
validationMessage: StringConstructor;
locale: {
type: (StringConstructor | {
(arrayLength: number): string[];
(...items: string[]): string[];
new (arrayLength: number): string[];
new (...items: string[]): string[];
isArray(arg: any): arg is any[];
readonly prototype: any[];
from<T>(arrayLike: ArrayLike<T>): T[];
from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
of<T>(...items: T[]): T[];
readonly [Symbol.species]: ArrayConstructor;
})[];
default: () => string | string[] | null | undefined;
};
statusIcon: {
type: BooleanConstructor;
default: () => boolean;
};
}, unknown, {
isValid: boolean;
isFocused: boolean;
newIconPack: string;
_elementRef: string;
}, {
parentField(): CreateComponentPublicInstance<Readonly<ExtractPropTypes<    {
type: {
type: PropType<FieldTypeProp>;
default: undefined;
};
label: StringConstructor;
labelFor: StringConstructor;
message: {
type: PropType<FieldMessageProp>;
default: undefined;
};
grouped: BooleanConstructor;
groupMultiline: BooleanConstructor;
position: StringConstructor;
expanded: BooleanConstructor;
horizontal: BooleanConstructor;
addons: {
type: BooleanConstructor;
default: boolean;
};
customClass: StringConstructor;
labelPosition: {
type: StringConstructor;
default: () => FieldLabelPosition_2 | null | undefined;
};
}>>, unknown, {
newType: FieldTypeProp | null;
newMessage: FieldMessageProp | null;
fieldLabelSize: string | null;
numberInputClasses: string[];
_isField: boolean;
}, {
rootClasses(): (string[] | {
'is-expanded': boolean;
'is-horizontal': boolean;
'is-floating-in-label': boolean | "" | undefined;
'is-floating-label': boolean | "" | undefined;
})[];
innerFieldClasses(): (string | {
'is-grouped-multiline': boolean;
} | undefined)[];
hasInnerField(): boolean;
newPosition(): string | undefined;
formattedMessage(): string[] | "";
hasLabel(): string | Slot<any> | undefined;
hasMessage(): Slot<any> | FieldMessagePropItem | FieldMessagePropItem[] | undefined;
}, {
fieldType(): "is-grouped" | "has-addons" | undefined;
hasAddons(): boolean;
wrapNumberinput({ controlsPosition, size }: {
controlsPosition?: string;
size?: string;
}): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, VNodeProps & AllowedComponentProps & ComponentCustomProps & Readonly<ExtractPropTypes<    {
type: {
type: PropType<FieldTypeProp>;
default: undefined;
};
label: StringConstructor;
labelFor: StringConstructor;
message: {
type: PropType<FieldMessageProp>;
default: undefined;
};
grouped: BooleanConstructor;
groupMultiline: BooleanConstructor;
position: StringConstructor;
expanded: BooleanConstructor;
horizontal: BooleanConstructor;
addons: {
type: BooleanConstructor;
default: boolean;
};
customClass: StringConstructor;
labelPosition: {
type: StringConstructor;
default: () => FieldLabelPosition_2 | null | undefined;
};
}>>, {
type: FieldTypeProp;
expanded: boolean;
message: FieldMessageProp;
grouped: boolean;
groupMultiline: boolean;
horizontal: boolean;
addons: boolean;
labelPosition: string;
}, true, {}, {}, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<ExtractPropTypes<    {
type: {
type: PropType<FieldTypeProp>;
default: undefined;
};
label: StringConstructor;
labelFor: StringConstructor;
message: {
type: PropType<FieldMessageProp>;
default: undefined;
};
grouped: BooleanConstructor;
groupMultiline: BooleanConstructor;
position: StringConstructor;
expanded: BooleanConstructor;
horizontal: BooleanConstructor;
addons: {
type: BooleanConstructor;
default: boolean;
};
customClass: StringConstructor;
labelPosition: {
type: StringConstructor;
default: () => FieldLabelPosition_2 | null | undefined;
};
}>>, {}, {
newType: FieldTypeProp | null;
newMessage: FieldMessageProp | null;
fieldLabelSize: string | null;
numberInputClasses: string[];
_isField: boolean;
}, {
rootClasses(): (string[] | {
'is-expanded': boolean;
'is-horizontal': boolean;
'is-floating-in-label': boolean | "" | undefined;
'is-floating-label': boolean | "" | undefined;
})[];
innerFieldClasses(): (string | {
'is-grouped-multiline': boolean;
} | undefined)[];
hasInnerField(): boolean;
newPosition(): string | undefined;
formattedMessage(): string[] | "";
hasLabel(): string | Slot<any> | undefined;
hasMessage(): Slot<any> | FieldMessagePropItem | FieldMessagePropItem[] | undefined;
}, {
fieldType(): "is-grouped" | "has-addons" | undefined;
hasAddons(): boolean;
wrapNumberinput({ controlsPosition, size }: {
controlsPosition?: string;
size?: string;
}): void;
}, {
type: FieldTypeProp;
expanded: boolean;
message: FieldMessageProp;
grouped: boolean;
groupMultiline: boolean;
horizontal: boolean;
addons: boolean;
labelPosition: string;
}> | undefined;
statusType(): string | undefined;
statusMessage(): Slot<any> | FieldMessagePropItem | FieldMessagePropItem[] | undefined;
iconSize(): "" | "is-medium" | "is-small" | undefined;
}, {
focus(): void;
onBlur($event?: Event): void;
onFocus($event?: Event): void;
getElement(): HTMLInputElement | HTMLButtonElement | HTMLFieldSetElement | HTMLOutputElement | HTMLSelectElement | HTMLTextAreaElement;
setInvalid(): void;
setValidity(type: FieldTypeProp | null, message: FieldMessageProp | null): void;
checkHtml5Validity(): boolean;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
blur: (event?: Event) => true;
focus: (event?: Event) => true;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
size: StringConstructor;
expanded: BooleanConstructor;
loading: BooleanConstructor;
rounded: BooleanConstructor;
icon: StringConstructor;
iconPack: StringConstructor;
maxlength: (NumberConstructor | StringConstructor)[];
useHtml5Validation: {
type: BooleanConstructor;
default: () => boolean;
};
validationMessage: StringConstructor;
locale: {
type: (StringConstructor | {
(arrayLength: number): string[];
(...items: string[]): string[];
new (arrayLength: number): string[];
new (...items: string[]): string[];
isArray(arg: any): arg is any[];
readonly prototype: any[];
from<T>(arrayLike: ArrayLike<T>): T[];
from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
of<T>(...items: T[]): T[];
readonly [Symbol.species]: ArrayConstructor;
})[];
default: () => string | string[] | null | undefined;
};
statusIcon: {
type: BooleanConstructor;
default: () => boolean;
};
}>> & {
onFocus?: ((event?: Event | undefined) => any) | undefined;
onBlur?: ((event?: Event | undefined) => any) | undefined;
}, {
rounded: boolean;
loading: boolean;
expanded: boolean;
locale: string | string[];
useHtml5Validation: boolean;
statusIcon: boolean;
}, {}>, ComponentOptionsMixin, {
active: (active: boolean) => true;
blur: (event: Event) => true;
focus: (event?: Event) => true;
'icon-click': (event: MouseEvent) => true;
'icon-right-click': (event: MouseEvent) => true;
'infinite-scroll': () => true;
select: (selected: any, event?: Event) => true;
'select-footer': (event: Event) => true;
'select-header': (event: Event) => true;
typing: (value: number | string | null | undefined) => true;
'update:modelValue': (value: number | string) => true;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
modelValue: PropType<number | string | null>;
data: {
type: ArrayConstructor;
default: () => never[];
};
field: {
type: StringConstructor;
default: string;
};
keepFirst: BooleanConstructor;
clearOnSelect: BooleanConstructor;
openOnFocus: BooleanConstructor;
customFormatter: {
type: PropType<(option: any) => string>;
};
checkInfiniteScroll: BooleanConstructor;
keepOpen: BooleanConstructor;
selectOnClickOutside: BooleanConstructor;
clearable: BooleanConstructor;
maxHeight: (NumberConstructor | StringConstructor)[];
dropdownPosition: {
type: StringConstructor;
default: string;
};
groupField: StringConstructor;
groupOptions: StringConstructor;
iconRight: StringConstructor;
iconRightClickable: BooleanConstructor;
appendToBody: BooleanConstructor;
type: {
type: StringConstructor;
default: string;
};
confirmKeys: {
type: ArrayConstructor;
default: () => string[];
};
selectableHeader: BooleanConstructor;
selectableFooter: BooleanConstructor;
autocomplete: StringConstructor;
}>> & {
onFocus?: ((event?: Event | undefined) => any) | undefined;
onBlur?: ((event: Event) => any) | undefined;
onSelect?: ((selected: any, event?: Event | undefined) => any) | undefined;
"onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
"onIcon-click"?: ((event: MouseEvent) => any) | undefined;
"onIcon-right-click"?: ((event: MouseEvent) => any) | undefined;
onActive?: ((active: boolean) => any) | undefined;
"onInfinite-scroll"?: (() => any) | undefined;
"onSelect-footer"?: ((event: Event) => any) | undefined;
"onSelect-header"?: ((event: Event) => any) | undefined;
onTyping?: ((value: string | number | null | undefined) => any) | undefined;
}, {
data: unknown[];
field: string;
type: string;
iconRightClickable: boolean;
checkInfiniteScroll: boolean;
keepFirst: boolean;
appendToBody: boolean;
clearOnSelect: boolean;
openOnFocus: boolean;
keepOpen: boolean;
selectOnClickOutside: boolean;
clearable: boolean;
dropdownPosition: string;
confirmKeys: unknown[];
selectableHeader: boolean;
selectableFooter: boolean;
}, {}>;

export declare const BBreadcrumb: DefineComponent<    {
align: {
type: StringConstructor;
default: () => string;
};
separator: {
type: StringConstructor;
default: () => string;
};
size: {
type: StringConstructor;
default: () => string;
};
}, unknown, unknown, {
breadcrumbClasses(): string[];
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
align: {
type: StringConstructor;
default: () => string;
};
separator: {
type: StringConstructor;
default: () => string;
};
size: {
type: StringConstructor;
default: () => string;
};
}>>, {
size: string;
align: string;
separator: string;
}, {}>;

export declare const BBreadcrumbItem: DefineComponent<    {
tag: {
type: (StringConstructor | ObjectConstructor)[];
default: () => string;
};
active: BooleanConstructor;
}, unknown, unknown, {}, {}, DefineComponent<    {
compatFallthrough: {
type: BooleanConstructor;
default: () => boolean;
};
}, unknown, unknown, {
rootAttrs(): {
class: unknown;
style: StyleValue;
id: string | undefined;
} | {
class?: undefined;
style?: undefined;
id?: undefined;
};
fallthroughAttrs(): {
[x: string]: unknown;
};
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
compatFallthrough: {
type: BooleanConstructor;
default: () => boolean;
};
}>>, {
compatFallthrough: boolean;
}, {}>, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: (StringConstructor | ObjectConstructor)[];
default: () => string;
};
active: BooleanConstructor;
}>>, {
active: boolean;
tag: string | Record<string, any>;
}, {}>;

export declare const BButton: DefineComponent<    {
type: (StringConstructor | ObjectConstructor)[];
size: StringConstructor;
label: StringConstructor;
iconPack: StringConstructor;
iconLeft: StringConstructor;
iconRight: StringConstructor;
rounded: {
type: BooleanConstructor;
default: () => boolean;
};
loading: BooleanConstructor;
outlined: BooleanConstructor;
expanded: BooleanConstructor;
inverted: BooleanConstructor;
focused: BooleanConstructor;
active: BooleanConstructor;
hovered: BooleanConstructor;
selected: BooleanConstructor;
nativeType: {
type: PropType<ButtonNativeType>;
default: string;
validator: (value: unknown) => boolean;
};
tag: {
type: (StringConstructor | ObjectConstructor)[];
default: string;
validator: (value: unknown) => boolean;
};
}, unknown, unknown, {
computedTag(): string | Record<string, any>;
iconSize(): string;
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
type: (StringConstructor | ObjectConstructor)[];
size: StringConstructor;
label: StringConstructor;
iconPack: StringConstructor;
iconLeft: StringConstructor;
iconRight: StringConstructor;
rounded: {
type: BooleanConstructor;
default: () => boolean;
};
loading: BooleanConstructor;
outlined: BooleanConstructor;
expanded: BooleanConstructor;
inverted: BooleanConstructor;
focused: BooleanConstructor;
active: BooleanConstructor;
hovered: BooleanConstructor;
selected: BooleanConstructor;
nativeType: {
type: PropType<ButtonNativeType>;
default: string;
validator: (value: unknown) => boolean;
};
tag: {
type: (StringConstructor | ObjectConstructor)[];
default: string;
validator: (value: unknown) => boolean;
};
}>>, {
rounded: boolean;
loading: boolean;
outlined: boolean;
expanded: boolean;
inverted: boolean;
focused: boolean;
active: boolean;
hovered: boolean;
selected: boolean;
nativeType: "button" | "reset" | "submit";
tag: string | Record<string, any>;
}, {}>;

export declare const BCarousel: DefineComponent<    {
modelValue: {
type: NumberConstructor;
default: number;
};
animated: {
type: StringConstructor;
default: string;
};
interval: NumberConstructor;
hasDrag: {
type: BooleanConstructor;
default: boolean;
};
autoplay: {
type: BooleanConstructor;
default: boolean;
};
pauseHover: {
type: BooleanConstructor;
default: boolean;
};
pauseInfo: {
type: BooleanConstructor;
default: boolean;
};
pauseInfoType: {
type: StringConstructor;
default: string;
};
pauseText: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
arrowHover: {
type: BooleanConstructor;
default: boolean;
};
repeat: {
type: BooleanConstructor;
default: boolean;
};
iconPack: StringConstructor;
iconSize: StringConstructor;
iconPrev: {
type: StringConstructor;
default: () => string;
};
iconNext: {
type: StringConstructor;
default: () => string;
};
indicator: {
type: BooleanConstructor;
default: boolean;
};
indicatorBackground: BooleanConstructor;
indicatorCustom: BooleanConstructor;
indicatorCustomSize: {
type: StringConstructor;
default: string;
};
indicatorInside: {
type: BooleanConstructor;
default: boolean;
};
indicatorMode: {
type: PropType<IndicatorMode>;
default: string;
};
indicatorPosition: {
type: StringConstructor;
default: string;
};
indicatorStyle: {
type: StringConstructor;
default: string;
};
overlay: BooleanConstructor;
progress: BooleanConstructor;
progressType: {
type: StringConstructor;
default: string;
};
withCarouselList: BooleanConstructor;
}, unknown, {
transition: string;
activeChild: number;
isPause: boolean;
dragX: number | false;
timer: ReturnType<typeof setInterval> | undefined;
}, {
indicatorClasses(): (string | false | {
'has-background': boolean;
'has-custom': boolean;
'is-inside': boolean;
})[];
hasPrev(): boolean;
hasNext(): boolean;
activeChildIndex(): number | undefined;
}, {
startTimer(): void;
pauseTimer(): void;
restartTimer(): void;
checkPause(): void;
changeActive(newIndex: number, direction?: number): void;
modeChange(trigger: IndicatorMode, value: number): void;
prev(): void;
next(): void;
dragStart(event: MouseEvent | TouchEvent): void;
dragEnd(event: MouseEvent | TouchEvent): void;
}, ProviderParentMixin<3, ICarouselItem>, ComponentOptionsMixin, {
change: (_index: number) => true;
click: () => true;
'update:modelValue': (_value: number) => true;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: NumberConstructor;
default: number;
};
animated: {
type: StringConstructor;
default: string;
};
interval: NumberConstructor;
hasDrag: {
type: BooleanConstructor;
default: boolean;
};
autoplay: {
type: BooleanConstructor;
default: boolean;
};
pauseHover: {
type: BooleanConstructor;
default: boolean;
};
pauseInfo: {
type: BooleanConstructor;
default: boolean;
};
pauseInfoType: {
type: StringConstructor;
default: string;
};
pauseText: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
arrowHover: {
type: BooleanConstructor;
default: boolean;
};
repeat: {
type: BooleanConstructor;
default: boolean;
};
iconPack: StringConstructor;
iconSize: StringConstructor;
iconPrev: {
type: StringConstructor;
default: () => string;
};
iconNext: {
type: StringConstructor;
default: () => string;
};
indicator: {
type: BooleanConstructor;
default: boolean;
};
indicatorBackground: BooleanConstructor;
indicatorCustom: BooleanConstructor;
indicatorCustomSize: {
type: StringConstructor;
default: string;
};
indicatorInside: {
type: BooleanConstructor;
default: boolean;
};
indicatorMode: {
type: PropType<IndicatorMode>;
default: string;
};
indicatorPosition: {
type: StringConstructor;
default: string;
};
indicatorStyle: {
type: StringConstructor;
default: string;
};
overlay: BooleanConstructor;
progress: BooleanConstructor;
progressType: {
type: StringConstructor;
default: string;
};
withCarouselList: BooleanConstructor;
}>> & {
onChange?: ((_index: number) => any) | undefined;
onClick?: (() => any) | undefined;
"onUpdate:modelValue"?: ((_value: number) => any) | undefined;
}, {
progress: boolean;
repeat: boolean;
modelValue: number;
autoplay: boolean;
animated: string;
hasDrag: boolean;
pauseHover: boolean;
pauseInfo: boolean;
pauseInfoType: string;
pauseText: string;
arrow: boolean;
arrowHover: boolean;
iconPrev: string;
iconNext: string;
indicator: boolean;
indicatorBackground: boolean;
indicatorCustom: boolean;
indicatorCustomSize: string;
indicatorInside: boolean;
indicatorMode: "click" | "hover";
indicatorPosition: string;
indicatorStyle: string;
overlay: boolean;
progressType: string;
withCarouselList: boolean;
}, {}>;

export declare const BCarouselItem: DefineComponent<    {}, {}, {
transitionName: null;
}, {
transition(): string | undefined;
isActive(): boolean;
}, {}, InjectedChildMixin<1, ICarousel>, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;

export declare const BCarouselList: DefineComponent<    {
data: {
type: {
(arrayLength: number): any[];
(...items: any[]): any[];
new (arrayLength: number): any[];
new (...items: any[]): any[];
isArray(arg: any): arg is any[];
readonly prototype: any[];
from<T>(arrayLike: ArrayLike<T>): T[];
from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
of<T>(...items: T[]): T[];
readonly [Symbol.species]: ArrayConstructor;
};
default: () => never[];
};
modelValue: {
type: NumberConstructor;
default: number;
};
scrollValue: {
type: NumberConstructor;
default: number;
};
hasDrag: {
type: BooleanConstructor;
default: boolean;
};
hasGrayscale: BooleanConstructor;
hasOpacity: BooleanConstructor;
repeat: BooleanConstructor;
itemsToShow: {
type: NumberConstructor;
default: number;
};
itemsToList: {
type: NumberConstructor;
default: number;
};
asIndicator: BooleanConstructor;
arrow: {
type: BooleanConstructor;
default: boolean;
};
arrowHover: {
type: BooleanConstructor;
default: boolean;
};
iconPack: StringConstructor;
iconSize: StringConstructor;
iconPrev: {
type: StringConstructor;
default: () => string;
};
iconNext: {
type: StringConstructor;
default: () => string;
};
breakpoints: {
type: PropType<Record<number, BreakpointOptions>>;
default: () => {};
};
}, unknown, {
activeItem: number;
scrollIndex: number;
delta: number;
dragX: number | false;
hold: number;
windowWidth: number;
touch: boolean;
observer: ResizeObserver | null;
refresh_: number;
}, {
dragging(): boolean;
listClass(): {
'has-grayscale': boolean | undefined;
'has-opacity': boolean | undefined;
'is-dragging': boolean;
}[];
itemStyle(): string;
translation(): number;
total(): number;
hasPrev(): boolean;
hasNext(): boolean;
breakpointKeys(): string[];
settings(): BreakpointSettings;
itemWidth(): number;
}, {
resized(): void;
switchTo(newIndex: number): void;
next(): void;
prev(): void;
checkAsIndicator(value: number, event: MouseEvent | TouchEvent): void;
dragStart(event: MouseEvent | TouchEvent): void;
dragMove(event: MouseEvent | TouchEvent): void;
dragEnd(): void;
refresh(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
switch: (_value: number) => true;
'update:modelValue': (_value: number) => true;
'updated:scroll': (_index: number) => true;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
data: {
type: {
(arrayLength: number): any[];
(...items: any[]): any[];
new (arrayLength: number): any[];
new (...items: any[]): any[];
isArray(arg: any): arg is any[];
readonly prototype: any[];
from<T>(arrayLike: ArrayLike<T>): T[];
from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
of<T>(...items: T[]): T[];
readonly [Symbol.species]: ArrayConstructor;
};
default: () => never[];
};
modelValue: {
type: NumberConstructor;
default: number;
};
scrollValue: {
type: NumberConstructor;
default: number;
};
hasDrag: {
type: BooleanConstructor;
default: boolean;
};
hasGrayscale: BooleanConstructor;
hasOpacity: BooleanConstructor;
repeat: BooleanConstructor;
itemsToShow: {
type: NumberConstructor;
default: number;
};
itemsToList: {
type: NumberConstructor;
default: number;
};
asIndicator: BooleanConstructor;
arrow: {
type: BooleanConstructor;
default: boolean;
};
arrowHover: {
type: BooleanConstructor;
default: boolean;
};
iconPack: StringConstructor;
iconSize: StringConstructor;
iconPrev: {
type: StringConstructor;
default: () => string;
};
iconNext: {
type: StringConstructor;
default: () => string;
};
breakpoints: {
type: PropType<Record<number, BreakpointOptions>>;
default: () => {};
};
}>> & {
"onUpdate:modelValue"?: ((_value: number) => any) | undefined;
onSwitch?: ((_value: number) => any) | undefined;
"onUpdated:scroll"?: ((_index: number) => any) | undefined;
}, {
data: any[];
repeat: boolean;
modelValue: number;
hasDrag: boolean;
arrow: boolean;
arrowHover: boolean;
iconPrev: string;
iconNext: string;
scrollValue: number;
hasGrayscale: boolean;
hasOpacity: boolean;
itemsToShow: number;
itemsToList: number;
asIndicator: boolean;
breakpoints: Record<number, Partial<BreakpointSettings>>;
}, {}>;

export declare const BCheckbox: DefineComponent<    {
indeterminate: BooleanConstructor;
ariaLabelledby: StringConstructor;
trueValue: {
type: (ArrayConstructor | NumberConstructor | StringConstructor | ObjectConstructor | BooleanConstructor | FunctionConstructor)[];
default: boolean;
};
falseValue: {
type: (ArrayConstructor | NumberConstructor | StringConstructor | ObjectConstructor | BooleanConstructor | FunctionConstructor)[];
default: boolean;
};
autocomplete: {
type: StringConstructor;
default: string;
};
inputId: {
type: StringConstructor;
default: string;
};
}, unknown, unknown, {}, {}, DefineComponent<    {
modelValue: (ArrayConstructor | NumberConstructor | StringConstructor | ObjectConstructor | BooleanConstructor | FunctionConstructor)[];
nativeValue: (ArrayConstructor | NumberConstructor | StringConstructor | ObjectConstructor | BooleanConstructor | FunctionConstructor)[];
type: StringConstructor;
disabled: BooleanConstructor;
required: BooleanConstructor;
name: StringConstructor;
size: StringConstructor;
}, unknown, {
newValue: string | number | boolean | Function | unknown[] | Record<string, any> | undefined;
}, {
computedValue: {
get(): string | number | boolean | Function | unknown[] | Record<string, any> | undefined;
set(value: any): void;
};
disabledOrUndefined(): true | undefined;
requiredOrUndefined(): true | undefined;
}, {
focus(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
'update:modelValue': (value: any) => true;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
modelValue: (ArrayConstructor | NumberConstructor | StringConstructor | ObjectConstructor | BooleanConstructor | FunctionConstructor)[];
nativeValue: (ArrayConstructor | NumberConstructor | StringConstructor | ObjectConstructor | BooleanConstructor | FunctionConstructor)[];
type: StringConstructor;
disabled: BooleanConstructor;
required: BooleanConstructor;
name: StringConstructor;
size: StringConstructor;
}>> & {
"onUpdate:modelValue"?: ((value: any) => any) | undefined;
}, {
required: boolean;
disabled: boolean;
}, {}>, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
indeterminate: BooleanConstructor;
ariaLabelledby: StringConstructor;
trueValue: {
type: (ArrayConstructor | NumberConstructor | StringConstructor | ObjectConstructor | BooleanConstructor | FunctionConstructor)[];
default: boolean;
};
falseValue: {
type: (ArrayConstructor | NumberConstructor | StringConstructor | ObjectConstructor | BooleanConstructor | FunctionConstructor)[];
default: boolean;
};
autocomplete: {
type: StringConstructor;
default: string;
};
inputId: {
type: StringConstructor;
default: string;
};
}>>, {
autocomplete: string;
indeterminate: boolean;
trueValue: string | number | boolean | Function | unknown[] | Record<string, any>;
falseValue: string | number | boolean | Function | unknown[] | Record<string, any>;
inputId: string;
}, {}>;

export declare const BCheckboxButton: DefineComponent<    {
type: {
type: StringConstructor;
default: string;
};
expanded: BooleanConstructor;
}, unknown, {
isFocused: boolean;
}, {
checked(): boolean;
}, {}, DefineComponent<    {
modelValue: (ArrayConstructor | NumberConstructor | StringConstructor | ObjectConstructor | BooleanConstructor | FunctionConstructor)[];
nativeValue: (ArrayConstructor | NumberConstructor | StringConstructor | ObjectConstructor | BooleanConstructor | FunctionConstructor)[];
type: StringConstructor;
disabled: BooleanConstructor;
required: BooleanConstructor;
name: StringConstructor;
size: StringConstructor;
}, unknown, {
newValue: string | number | boolean | Function | unknown[] | Record<string, any> | undefined;
}, {
computedValue: {
get(): string | number | boolean | Function | unknown[] | Record<string, any> | undefined;
set(value: any): void;
};
disabledOrUndefined(): true | undefined;
requiredOrUndefined(): true | undefined;
}, {
focus(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
'update:modelValue': (value: any) => true;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
modelValue: (ArrayConstructor | NumberConstructor | StringConstructor | ObjectConstructor | BooleanConstructor | FunctionConstructor)[];
nativeValue: (ArrayConstructor | NumberConstructor | StringConstructor | ObjectConstructor | BooleanConstructor | FunctionConstructor)[];
type: StringConstructor;
disabled: BooleanConstructor;
required: BooleanConstructor;
name: StringConstructor;
size: StringConstructor;
}>> & {
"onUpdate:modelValue"?: ((value: any) => any) | undefined;
}, {
required: boolean;
disabled: boolean;
}, {}>, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
};
expanded: BooleanConstructor;
}>>, {
type: string;
expanded: boolean;
}, {}>;

export declare const BClockpicker: DefineComponent<    {
pickerSize: {
type: NumberConstructor;
default: number;
};
incrementMinutes: {
type: NumberConstructor;
default: number;
};
type: {
type: StringConstructor;
default: string;
};
hoursLabel: {
type: StringConstructor;
default: () => string;
};
minutesLabel: {
type: StringConstructor;
default: () => string;
};
}, unknown, {
isSelectingHour: boolean;
isDragging: boolean;
_isClockpicker: boolean;
}, {
hoursDisplay(): string | number;
minutesDisplay(): string;
minFaceValue(): 0 | 12;
maxFaceValue(): 11 | 59 | 23;
faceSize(): number;
faceDisabledValues(): (hour: number) => boolean;
}, {
onClockInput(value: number): void;
onClockChange(): void;
toggle(active: boolean): void;
onMeridienClick(value: string): void;
onInputClick(event: MouseEvent): void;
}, DefineComponent<    {
modelValue: PropType<Date | null>;
inline: BooleanConstructor;
minTime: PropType<Date | null>;
maxTime: PropType<Date | null>;
placeholder: StringConstructor;
editable: BooleanConstructor;
disabled: BooleanConstructor;
hourFormat: {
type: PropType<HourFormat>;
validator: (value: unknown) => value is "24" | "12";
};
incrementHours: {
type: NumberConstructor;
default: number;
};
incrementMinutes: {
type: NumberConstructor;
default: number;
};
incrementSeconds: {
type: NumberConstructor;
default: number;
};
timeFormatter: {
type: PropType<TimeFormatter>;
default: (date: Date, vm: ITimepickerMixin) => string;
};
timeParser: {
type: PropType<TimeParser>;
default: (date: string, vm: ITimepickerMixin) => Date | null;
};
mobileNative: {
type: BooleanConstructor;
default: () => boolean;
};
mobileModal: {
type: BooleanConstructor;
default: () => boolean;
};
timeCreator: {
type: PropType<TimeCreator>;
default: () => Date;
};
position: StringConstructor;
unselectableTimes: {
(arrayLength: number): Date[];
(...items: Date[]): Date[];
new (arrayLength: number): Date[];
new (...items: Date[]): Date[];
isArray(arg: any): arg is any[];
readonly prototype: any[];
from<T>(arrayLike: ArrayLike<T>): T[];
from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
of<T>(...items: T[]): T[];
readonly [Symbol.species]: ArrayConstructor;
};
openOnFocus: BooleanConstructor;
enableSeconds: BooleanConstructor;
defaultMinutes: NumberConstructor;
defaultSeconds: NumberConstructor;
focusable: {
type: BooleanConstructor;
default: boolean;
};
tzOffset: {
type: NumberConstructor;
default: number;
};
appendToBody: BooleanConstructor;
resetOnMeridianChange: {
type: BooleanConstructor;
default: boolean;
};
}, unknown, {
dateSelected: Date | null | undefined;
hoursSelected: number | null;
minutesSelected: number | null;
secondsSelected: number | null;
meridienSelected: string | null;
_elementRef: string;
AM: string;
PM: string;
HOUR_FORMAT_24: string;
HOUR_FORMAT_12: string;
}, {
computedValue: {
get(): {
toString: () => string;
toDateString: () => string;
toTimeString: () => string;
toLocaleString: {
(): string;
(locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
};
toLocaleDateString: {
(): string;
(locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
};
toLocaleTimeString: {
(): string;
(locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
};
valueOf: () => number;
getTime: () => number;
getFullYear: () => number;
getUTCFullYear: () => number;
getMonth: () => number;
getUTCMonth: () => number;
getDate: () => number;
getUTCDate: () => number;
getDay: () => number;
getUTCDay: () => number;
getHours: () => number;
getUTCHours: () => number;
getMinutes: () => number;
getUTCMinutes: () => number;
getSeconds: () => number;
getUTCSeconds: () => number;
getMilliseconds: () => number;
getUTCMilliseconds: () => number;
getTimezoneOffset: () => number;
setTime: (time: number) => number;
setMilliseconds: (ms: number) => number;
setUTCMilliseconds: (ms: number) => number;
setSeconds: (sec: number, ms?: number) => number;
setUTCSeconds: (sec: number, ms?: number) => number;
setMinutes: (min: number, sec?: number, ms?: number) => number;
setUTCMinutes: (min: number, sec?: number, ms?: number) => number;
setHours: (hours: number, min?: number, sec?: number, ms?: number) => number;
setUTCHours: (hours: number, min?: number, sec?: number, ms?: number) => number;
setDate: (date: number) => number;
setUTCDate: (date: number) => number;
setMonth: (month: number, date?: number) => number;
setUTCMonth: (month: number, date?: number) => number;
setFullYear: (year: number, month?: number, date?: number) => number;
setUTCFullYear: (year: number, month?: number, date?: number) => number;
toUTCString: () => string;
toISOString: () => string;
toJSON: (key?: any) => string;
[Symbol.toPrimitive]: {
(hint: "default"): string;
(hint: "string"): string;
(hint: "number"): number;
(hint: string): string | number;
};
} | null | undefined;
set(value: Date | null): void;
};
localeOptions(): Intl.DateTimeFormatOptions;
dtf(): Intl.DateTimeFormat;
newHourFormat(): HourFormat;
sampleTime(): Date;
hourLiteral(): string;
minuteLiteral(): string;
secondLiteral(): string | undefined;
amString(): string;
pmString(): string;
hours(): {
label: string;
value: number;
}[];
minutes(): {
label: string;
value: number;
}[];
seconds(): {
label: string;
value: number;
}[];
meridiens(): string[];
isMobile(): boolean | RegExpMatchArray | null;
isHourFormat24(): boolean;
disabledOrUndefined(): true | undefined;
}, {
onMeridienChange(value: string): void;
onHoursChange(value: number | string): void;
onMinutesChange(value: number | string): void;
onSecondsChange(value: number | string): void;
updateDateSelected(hours: number | null, minutes: number | null, seconds: number | null, meridiens: string | null): void;
updateInternalState(value?: Date | null): void;
isHourDisabled(hour: number): boolean;
isMinuteDisabledForHour(hour: number, minute: number): boolean;
isMinuteDisabled(minute: number): boolean;
isSecondDisabled(second: number): boolean;
onChange(value: string): void;
toggle(active: boolean): void;
close(): void;
handleOnFocus(): void;
formatHHMMSS(value: Date | null | undefined): string;
onChangeNativePicker(event: {
target: EventTarget;
}): void;
formatNumber(value: number, prependZero?: boolean): string;
pad(value: number): string;
formatValue(date: Date | null | undefined): string | null;
keyPress({ key }: {
key: KeyboardEvent["key"];
}): void;
onActiveChange(value: boolean): void;
}, DefineComponent<    {
compatFallthrough: {
type: BooleanConstructor;
default: () => boolean;
};
}, unknown, unknown, {
rootAttrs(): {
class: unknown;
style: StyleValue;
id: string | undefined;
} | {
class?: undefined;
style?: undefined;
id?: undefined;
};
fallthroughAttrs(): {
[x: string]: unknown;
};
}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
compatFallthrough: {
type: BooleanConstructor;
default: () => boolean;
};
}>>, {
compatFallthrough: boolean;
}, {}> | DefineComponent<    {
size: StringConstructor;
expanded: BooleanConstructor;
loading: BooleanConstructor;
rounded: BooleanConstructor;
icon: StringConstructor;
iconPack: StringConstructor;
maxlength: (NumberConstructor | StringConstructor)[];
useHtml5Validation: {
type: BooleanConstructor;
default: () => boolean;
};
validationMessage: StringConstructor;
locale: {
type: (StringConstructor | {
(arrayLength: number): string[];
(...items: string[]): string[];
new (arrayLength: number): string[];
new (...items: string[]): string[];
isArray(arg: any): arg is any[];
readonly prototype: any[];
from<T>(arrayLike: ArrayLike<T>): T[];
from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
of<T>(...items: T[]): T[];
readonly [Symbol.species]: ArrayConstructor;
})[];
default: () => string | string[] | null | undefined;
};
statusIcon: {
type: BooleanConstructor;
default: () => boolean;
};
}, unknown, {
isValid: boolean;
isFocused: boolean;
newIconPack: string;
_elementRef: string;
}, {
parentField(): CreateComponentPublicInstance<Readonly<ExtractPropTypes<    {
type: {
type: PropType<FieldTypeProp>;
default: undefined;
};
label: StringConstructor;
labelFor: StringConstructor;
message: {
type: PropType<FieldMessageProp>;
default: undefined;
};
grouped: BooleanConstructor;
groupMultiline: BooleanConstructor;
position: StringConstructor;
expanded: BooleanConstructor;
horizontal: BooleanConstructor;
addons: {
type: BooleanConstructor;
default: boolean;
};
customClass: StringConstructor;
labelPosition: {
type: StringConstructor;
default: () => FieldLabelPosition_2 | null | undefined;
};
}>>, unknown, {
newType: FieldTypeProp | null;
newMessage: FieldMessageProp | null;
fieldLabelSize: string | null;
numberInputClasses: string[];
_isField: boolean;
}, {
rootClasses(): (string[] | {
'is-expanded': boolean;
'is-horizontal': boolean;
'is-floating-in-label': boolean | "" | undefined;
'is-floating-label': boolean | "" | undefined;
})[];
innerFieldClasses(): (string | {
'is-grouped-multiline': boolean;
} | undefined)[];
hasInnerField(): boolean;
newPosition(): string | undefined;
formattedMessage(): string[] | "";
hasLabel(): string | Slot<any> | undefined;
hasMessage(): Slot<any> | FieldMessagePropItem | FieldMessagePropItem[] | undefined;
}, {
fieldType(): "is-grouped" | "has-addons" | undefined;
hasAddons(): boolean;
wrapNumberinput({ controlsPosition, size }: {
controlsPosition?: string;
size?: string;
}): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, VNodeProps & AllowedComponentProps & ComponentCustomProps & Readonly<ExtractPropTypes<    {
type: {
type: PropType<FieldTypeProp>;
default: undefined;
};
label: StringConstructor;
labelFor: StringConstructor;
message: {
type: PropType<FieldMessageProp>;
default: undefined;
};
grouped: BooleanConstructor;
groupMultiline: BooleanConstructor;
position: StringConstructor;
expanded: BooleanConstructor;
horizontal: BooleanConstructor;
addons: {
type: BooleanConstructor;
default: boolean;
};
customClass: StringConstructor;
labelPosition: {
type: StringConstructor;
default: () => FieldLabelPosition_2 | null | undefined;
};
}>>, {
type: FieldTypeProp;
expanded: boolean;
message: FieldMessageProp;
grouped: boolean;
groupMultiline: boolean;
horizontal: boolean;
addons: boolean;
labelPosition: string;
}, true, {}, {}, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<ExtractPropTypes<    {
type: {
type: PropType<FieldTypeProp>;
default: undefined;
};
label: StringConstructor;
labelFor: StringConstructor;
message: {
type: PropType<FieldMessageProp>;
default: undefined;
};
grouped: BooleanConstructor;
groupMultiline: BooleanConstructor;
position: StringConstructor;
expanded: BooleanConstructor;
horizontal: BooleanConstructor;
addons: {
type: BooleanConstructor;
default: boolean;
};
customClass: StringConstructor;
labelPosition: {
type: StringConstructor;
default: () => FieldLabelPosition_2 | null | undefined;
};
}>>, {}, {
newType: FieldTypeProp | null;
newMessage: FieldMessageProp | null;
fieldLabelSize: string | null;
numberInputClasses: string[];
_isField: boolean;
}, {
rootClasses(): (string[] | {
'is-expanded': boolean;
'is-horizontal': boolean;
'is-floating-in-label': boolean | "" | undefined;
'is-floating-label': boolean | "" | undefined;
})[];
innerFieldClasses(): (string | {
'is-grouped-multiline': boolean;
} | undefined)[];
hasInnerField(): boolean;
newPosition(): string | undefined;
formattedMessage(): string[] | "";
hasLabel(): string | Slot<any> | undefined;
hasMessage(): Slot<any> | FieldMessagePropItem | FieldMessagePropItem[] | undefined;
}, {
fieldType(): "is-grouped" | "has-addons" | undefined;
hasAddons(): boolean;
wrapNumberinput({ controlsPosition, size }: {
controlsPosition?: string;
size?: string;
}): void;
}, {
type: FieldTypeProp;
expanded: boolean;
message: FieldMessageProp;
grouped: boolean;
groupMultiline: boolean;
horizontal: boolean;
addons: boolean;
labelPosition: string;
}> | undefined;
statusType(): string | undefined;
statusMessage(): Slot<any> | FieldMessagePropItem | FieldMessagePropItem[] | undefined;
iconSize(): "" | "is-medium" | "is-small" | undefined;
}, {
focus(): void;
onBlur($event?: Event): void;
onFocus($event?: Event): void;
getElement(): HTMLInputElement | HTMLButtonElement | HTMLFieldSetElement | HTMLOutputElement | HTMLSelectElement | HTMLTextAreaElement;
setInvalid(): void;
setValidity(type: FieldTypeProp | null, message: FieldMessageProp | null): void;
checkHtml5Validity(): boolean;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
blur: (event?: Event) => true;
focus: (event?: Event) => true;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
size: StringConstructor;
expanded: BooleanConstructor;
loading: BooleanConstructor;
rounded: BooleanConstructor;
icon: StringConstructor;
iconPack: StringConstructor;
maxlength: (NumberConstructor | StringConstructor)[];
useHtml5Validation: {
type: BooleanConstructor;
default: () => boolean;
};
validationMessage: StringConstructor;
locale: {
type: (StringConstructor | {
(arrayLength: number): string[];
(...items: string[]): string[];
new (arrayLength: number): string[];
new (...items: string[]): string[];
isArray(arg: any): arg is any[];
readonly prototype: any[];
from<T>(arrayLike: ArrayLike<T>): T[];
from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
of<T>(...items: T[]): T[];
readonly [Symbol.species]: ArrayConstructor;
})[];
default: () => string | string[] | null | undefined;
};
statusIcon: {
type: BooleanConstructor;
default: () => boolean;
};
}>> & {
onFocus?: ((event?: Event | undefined) => any) | undefined;
onBlur?: ((event?: Event | undefined) => any) | undefined;
}, {
rounded: boolean;
loading: boolean;
expanded: boolean;
locale: string | string[];
useHtml5Validation: boolean;
statusIcon: boolean;
}, {}>, ComponentOptionsMixin, {
'update:modelValue': (_value: Date | null) => true;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
modelValue: PropType<Date | null>;
inline: BooleanConstructor;
minTime: PropType<Date | null>;
maxTime: PropType<Date | null>;
placeholder: StringConstructor;
editable: BooleanConstructor;
disabled: BooleanConstructor;
hourFormat: {
type: PropType<HourFormat>;
validator: (value: unknown) => value is "24" | "12";
};
incrementHours: {
type: NumberConstructor;
default: number;
};
incrementMinutes: {
type: NumberConstructor;
default: number;
};
incrementSeconds: {
type: NumberConstructor;
default: number;
};
timeFormatter: {
type: PropType<TimeFormatter>;
default: (date: Date, vm: ITimepickerMixin) => string;
};
timeParser: {
type: PropType<TimeParser>;
default: (date: string,