bootstrap-vue-3/dist/composables/index.d.ts

Early (but lovely) implementation of Vue 3, Bootstrap 5 and Typescript

import useAlignment from './useAlignment';
import useBooleanish from './useBooleanish';
import { createBreadcrumb, useBreadcrumb } from './useBreadcrumb';
import useEventListener from './useEventListener';
import { bindGroupProps, getClasses, getGroupAttr, getGroupClasses, getInputClasses, getLabelClasses, optionToElement, slotsToElements } from './useFormCheck';
import useFormInput, { COMMON_INPUT_PROPS } from './useFormInput';
import { normalizeOptions } from './useFormSelect';
import useId from './useId';
export { useAlignment, createBreadcrumb, useBreadcrumb, useEventListener, bindGroupProps, useBooleanish, getClasses, getGroupAttr, getGroupClasses, getInputClasses, getLabelClasses, optionToElement, slotsToElements, useFormInput, COMMON_INPUT_PROPS, normalizeOptions, useId, };
declare const _default: {
    useAlignment: (align: import("vue").Ref<import("../types/Alignment").default>) => import("vue").ComputedRef<string>;
    createBreadcrumb: (app: import("vue").App<any>) => void;
    useBooleanish: typeof useBooleanish;
    useBreadcrumb: () => import("./useBreadcrumb").UseBreadcrumbI;
    useEventListener: (element: import("vue").Ref<HTMLElement | undefined>, event: string, callback: EventListener) => void;
    bindGroupProps: (el: any, idx: number, props: any, computedName: import("vue").ComputedRef<any>, computedId: import("vue").ComputedRef<any>) => any;
    getClasses: (items: {
        plain?: boolean | undefined;
        button?: boolean | undefined;
        inline?: boolean | undefined;
        switch?: boolean | undefined;
        size?: import("../types/InputSize").default | undefined;
    }) => import("vue").ComputedRef<any>;
    getGroupAttr: (items: {
        required?: boolean | undefined;
        ariaInvalid?: import("../types/AriaInvalid").default | undefined;
        state?: boolean | undefined;
    }) => import("vue").ComputedRef<any>;
    getGroupClasses: (items: {
        validated?: boolean | undefined;
        buttons?: boolean | undefined;
        stacked?: boolean | undefined;
        size?: import("../types/InputSize").default | undefined;
    }) => import("vue").ComputedRef<any>;
    getInputClasses: (items: {
        plain?: boolean | undefined;
        button?: boolean | undefined;
        state?: boolean | undefined;
    }) => import("vue").ComputedRef<any>;
    getLabelClasses: (items: {
        plain?: boolean | undefined;
        button?: boolean | undefined;
        buttonVariant?: import("../types/ButtonVariant").default | undefined;
        size?: import("../types/InputSize").default | undefined;
    }) => import("vue").ComputedRef<any>;
    optionToElement: (option: any, props: any) => any;
    slotsToElements: (slots: any[], nodeType: string, disabled: boolean) => {
        props: any;
        text: any;
    }[];
    useFormInput: (props: Readonly<{
        number: boolean;
        trim: boolean;
        required: boolean;
        modelValue: string | number;
        disabled: boolean;
        plaintext: boolean;
        lazy: boolean;
        state: boolean | null | undefined;
        autofocus: boolean;
        lazyFormatter: boolean;
        readonly: boolean;
    } & {
        id?: string | undefined;
        size?: import("../types/Size").default;
        name?: string | undefined;
        form?: string | undefined;
        ariaInvalid?: import("../types/AriaInvalid").default | undefined;
        autocomplete?: string | undefined;
        formatter?: Function | undefined;
        list?: string | undefined;
        placeholder?: string | undefined;
    }>, emit: (event: "update:modelValue" | "input" | "change" | "blur", ...args: any[]) => void) => {
        input: import("vue").Ref<HTMLInputElement | undefined>;
        computedId: import("vue").ComputedRef<string>;
        computedAriaInvalid: import("vue").ComputedRef<boolean | "true" | "false" | "grammar" | "spelling" | undefined>;
        onInput: (evt: Event) => void;
        onChange: (evt: Event) => void;
        onBlur: (evt: FocusEvent) => void;
        focus: () => void;
        blur: () => void;
    };
    COMMON_INPUT_PROPS: {
        ariaInvalid: {
            type: import("vue").PropType<import("../types/AriaInvalid").default>;
            default: undefined;
        };
        autocomplete: {
            type: StringConstructor;
            required: boolean;
        };
        autofocus: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        form: {
            type: StringConstructor;
            required: boolean;
        };
        formatter: {
            type: FunctionConstructor;
            required: boolean;
        };
        id: {
            type: StringConstructor;
            required: boolean;
        };
        lazy: {
            type: BooleanConstructor;
            default: boolean;
        };
        lazyFormatter: {
            type: BooleanConstructor;
            default: boolean;
        };
        list: {
            type: StringConstructor;
            required: boolean;
        };
        modelValue: {
            type: import("vue").PropType<string | number>;
            default: string;
        };
        name: {
            type: StringConstructor;
            required: boolean;
        };
        number: {
            type: BooleanConstructor;
            default: boolean;
        };
        placeholder: {
            type: StringConstructor;
            required: boolean;
        };
        plaintext: {
            type: BooleanConstructor;
            default: boolean;
        };
        readonly: {
            type: BooleanConstructor;
            default: boolean;
        };
        required: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: import("vue").PropType<import("../types/Size").default>;
            required: boolean;
        };
        state: {
            type: import("vue").PropType<boolean | null | undefined>;
            default: null;
        };
        trim: {
            type: BooleanConstructor;
            default: boolean;
        };
    };
    normalizeOptions: (options: any[], componentName: string, props: Record<string, unknown>) => any;
    useId: (id?: import("vue").Ref<string | undefined> | undefined, suffix?: string | undefined) => import("vue").ComputedRef<string>;
};
export default _default;