voiptime-components 1.3.0 → 1.3.2

package/dist/index.d.ts

@@ -2,7 +2,10 @@ import { App } from 'vue';
 import { Component } from 'vue';
 import { ComponentOptionsMixin } from 'vue';
 import { ComponentProvideOptions } from 'vue';
+import { CreateComponentPublicInstanceWithMixins } from 'vue';
 import { DefineComponent } from 'vue';
+import { GlobalComponents } from 'vue';
+import { GlobalDirectives } from 'vue';
 import { InjectionKey } from 'vue';
 import { ObjectDirective } from 'vue';
 import { PublicProps } from 'vue';
@@ -138,6 +141,7 @@ declare const __VLS_component_4: DefineComponent<__VLS_PublicProps, {
     selectOnClickRow: boolean;
     highlightCurrentRow: boolean;
     allData: Record<string, any>[];
+    hideHeader: boolean;
 }, {}, {}, {}, string, ComponentProvideOptions, false, {
     tableWrapperRef: HTMLDivElement;
 }, HTMLDivElement>;
@@ -176,6 +180,164 @@ declare const __VLS_component_6: DefineComponent<DropdownItemProps, {}, {}, {},
     onClick?: ((event: MouseEvent) => any) | undefined;
 }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLLIElement>;
 
+declare const __VLS_component_7: DefineComponent<VtSelectProps, {
+    focus(): void;
+    blur(): void;
+    clear(): void;
+    validate(): boolean;
+    clearValidation(): void;
+    getSelectedOptions(): VtSelectOption[];
+    getValidationState(): {
+        isValid: boolean;
+        errors: string[];
+    };
+    registerOption(option: VtSelectOption): void;
+    unregisterOption(value: string | number): void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    blur: (event: FocusEvent) => any;
+    change: (value: string | number | (string | number)[]) => any;
+    focus: (event: FocusEvent) => any;
+    filter: (query: string) => any;
+    "update:modelValue": (value: string | number | (string | number)[]) => any;
+    clear: () => any;
+    "visible-change": (visible: boolean) => any;
+    validation: (result: {
+        isValid: boolean;
+        errors: string[];
+    }) => any;
+    "remove-tag": (value: string | number) => any;
+}, string, PublicProps, Readonly<VtSelectProps> & Readonly<{
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((value: string | number | (string | number)[]) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onFilter?: ((query: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | number | (string | number)[]) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    "onVisible-change"?: ((visible: boolean) => any) | undefined;
+    onValidation?: ((result: {
+        isValid: boolean;
+        errors: string[];
+    }) => any) | undefined;
+    "onRemove-tag"?: ((value: string | number) => any) | undefined;
+}>, {
+    disabled: boolean;
+    loading: boolean;
+    size: VtSelectSize;
+    placeholder: string;
+    maxHeight: number | string;
+    placement: "bottom" | "bottom-start" | "bottom-end" | "top" | "top-start" | "top-end";
+    status: VtSelectStatus;
+    clearable: boolean;
+    validateOnInput: boolean;
+    validateOnBlur: boolean;
+    multiple: boolean;
+    collapsedTags: boolean;
+    filterable: boolean;
+    noDataText: string;
+    noMatchText: string;
+    loadingText: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    selectRef: HTMLDivElement;
+    triggerRef: HTMLDivElement;
+    containerRef: HTMLDivElement;
+    dropdownRef: HTMLDivElement;
+    filterInputRef: CreateComponentPublicInstanceWithMixins<Readonly< VtInputProps> & Readonly<{
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onChange?: ((event: Event) => any) | undefined;
+        onClick?: ((event: MouseEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        onInput?: ((event: Event) => any) | undefined;
+        onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+        onKeypress?: ((event: KeyboardEvent) => any) | undefined;
+        onKeyup?: ((event: KeyboardEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+        onClear?: (() => any) | undefined;
+        onValidation?: ((result: VtInputValidationResult) => any) | undefined;
+    }>, {
+        focus(): void;
+        blur(): void;
+        select(): void;
+        clear(): void;
+        validate(): boolean;
+        clearValidation(): void;
+        getInputElement(): HTMLInputElement | HTMLTextAreaElement | null;
+        getValidationState(): VtInputValidationResult;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+        blur: (event: FocusEvent) => any;
+        change: (event: Event) => any;
+        click: (event: MouseEvent) => any;
+        focus: (event: FocusEvent) => any;
+        input: (event: Event) => any;
+        keydown: (event: KeyboardEvent) => any;
+        keypress: (event: KeyboardEvent) => any;
+        keyup: (event: KeyboardEvent) => any;
+        "update:modelValue": (value: string | number) => any;
+        clear: () => any;
+        validation: (result: VtInputValidationResult) => any;
+    }, PublicProps, {
+        resize: VtInputResize;
+        type: VtInputType;
+        disabled: boolean;
+        size: VtInputSize;
+        status: VtInputStatus;
+        clearable: boolean;
+        showPassword: boolean;
+        rows: number;
+        autosize: boolean | VtInputAutosizeConfig;
+        validateOnInput: boolean;
+        validateOnBlur: boolean;
+    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+        textareaRef: HTMLTextAreaElement;
+        inputRef: HTMLInputElement;
+    }, HTMLDivElement, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< VtInputProps> & Readonly<{
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onChange?: ((event: Event) => any) | undefined;
+        onClick?: ((event: MouseEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        onInput?: ((event: Event) => any) | undefined;
+        onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+        onKeypress?: ((event: KeyboardEvent) => any) | undefined;
+        onKeyup?: ((event: KeyboardEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+        onClear?: (() => any) | undefined;
+        onValidation?: ((result: VtInputValidationResult) => any) | undefined;
+    }>, {
+        focus(): void;
+        blur(): void;
+        select(): void;
+        clear(): void;
+        validate(): boolean;
+        clearValidation(): void;
+        getInputElement(): HTMLInputElement | HTMLTextAreaElement | null;
+        getValidationState(): VtInputValidationResult;
+    }, {}, {}, {}, {
+        resize: VtInputResize;
+        type: VtInputType;
+        disabled: boolean;
+        size: VtInputSize;
+        status: VtInputStatus;
+        clearable: boolean;
+        showPassword: boolean;
+        rows: number;
+        autosize: boolean | VtInputAutosizeConfig;
+        validateOnInput: boolean;
+        validateOnBlur: boolean;
+    }> | null;
+}, HTMLDivElement>;
+
+declare const __VLS_component_8: DefineComponent<VtOptionProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    click: (option: VtSelectOption) => any;
+}, string, PublicProps, Readonly<VtOptionProps> & Readonly<{
+    onClick?: ((option: VtSelectOption) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
 declare type __VLS_Props = VTableProps;
 
 declare type __VLS_PublicProps = {
@@ -244,6 +406,118 @@ declare function __VLS_template_6(): {
     rootEl: HTMLLIElement;
 };
 
+declare function __VLS_template_7(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        selectRef: HTMLDivElement;
+        triggerRef: HTMLDivElement;
+        containerRef: HTMLDivElement;
+        dropdownRef: HTMLDivElement;
+        filterInputRef: CreateComponentPublicInstanceWithMixins<Readonly< VtInputProps> & Readonly<{
+            onBlur?: ((event: FocusEvent) => any) | undefined;
+            onChange?: ((event: Event) => any) | undefined;
+            onClick?: ((event: MouseEvent) => any) | undefined;
+            onFocus?: ((event: FocusEvent) => any) | undefined;
+            onInput?: ((event: Event) => any) | undefined;
+            onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+            onKeypress?: ((event: KeyboardEvent) => any) | undefined;
+            onKeyup?: ((event: KeyboardEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+            onClear?: (() => any) | undefined;
+            onValidation?: ((result: VtInputValidationResult) => any) | undefined;
+        }>, {
+            focus(): void;
+            blur(): void;
+            select(): void;
+            clear(): void;
+            validate(): boolean;
+            clearValidation(): void;
+            getInputElement(): HTMLInputElement | HTMLTextAreaElement | null;
+            getValidationState(): VtInputValidationResult;
+        }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+            blur: (event: FocusEvent) => any;
+            change: (event: Event) => any;
+            click: (event: MouseEvent) => any;
+            focus: (event: FocusEvent) => any;
+            input: (event: Event) => any;
+            keydown: (event: KeyboardEvent) => any;
+            keypress: (event: KeyboardEvent) => any;
+            keyup: (event: KeyboardEvent) => any;
+            "update:modelValue": (value: string | number) => any;
+            clear: () => any;
+            validation: (result: VtInputValidationResult) => any;
+        }, PublicProps, {
+            resize: VtInputResize;
+            type: VtInputType;
+            disabled: boolean;
+            size: VtInputSize;
+            status: VtInputStatus;
+            clearable: boolean;
+            showPassword: boolean;
+            rows: number;
+            autosize: boolean | VtInputAutosizeConfig;
+            validateOnInput: boolean;
+            validateOnBlur: boolean;
+        }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+            textareaRef: HTMLTextAreaElement;
+            inputRef: HTMLInputElement;
+        }, HTMLDivElement, ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly< VtInputProps> & Readonly<{
+            onBlur?: ((event: FocusEvent) => any) | undefined;
+            onChange?: ((event: Event) => any) | undefined;
+            onClick?: ((event: MouseEvent) => any) | undefined;
+            onFocus?: ((event: FocusEvent) => any) | undefined;
+            onInput?: ((event: Event) => any) | undefined;
+            onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+            onKeypress?: ((event: KeyboardEvent) => any) | undefined;
+            onKeyup?: ((event: KeyboardEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+            onClear?: (() => any) | undefined;
+            onValidation?: ((result: VtInputValidationResult) => any) | undefined;
+        }>, {
+            focus(): void;
+            blur(): void;
+            select(): void;
+            clear(): void;
+            validate(): boolean;
+            clearValidation(): void;
+            getInputElement(): HTMLInputElement | HTMLTextAreaElement | null;
+            getValidationState(): VtInputValidationResult;
+        }, {}, {}, {}, {
+            resize: VtInputResize;
+            type: VtInputType;
+            disabled: boolean;
+            size: VtInputSize;
+            status: VtInputStatus;
+            clearable: boolean;
+            showPassword: boolean;
+            rows: number;
+            autosize: boolean | VtInputAutosizeConfig;
+            validateOnInput: boolean;
+            validateOnBlur: boolean;
+        }> | null;
+    };
+    rootEl: HTMLDivElement;
+};
+
+declare function __VLS_template_8(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
 declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 
 declare type __VLS_TemplateResult_2 = ReturnType<typeof __VLS_template_2>;
@@ -256,6 +530,10 @@ declare type __VLS_TemplateResult_5 = ReturnType<typeof __VLS_template_5>;
 
 declare type __VLS_TemplateResult_6 = ReturnType<typeof __VLS_template_6>;
 
+declare type __VLS_TemplateResult_7 = ReturnType<typeof __VLS_template_7>;
+
+declare type __VLS_TemplateResult_8 = ReturnType<typeof __VLS_template_8>;
+
 declare type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;
@@ -292,6 +570,18 @@ declare type __VLS_WithTemplateSlots_6<T, S> = T & {
     };
 };
 
+declare type __VLS_WithTemplateSlots_7<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_8<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
 export declare const DEFAULT_COLUMN_CONFIG: {
     readonly sortable: true;
     readonly actionColumn: false;
@@ -571,6 +861,56 @@ export declare const VIcon: DefineComponent<Props, {}, {}, {}, {}, ComponentOpti
     color: string;
 }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 
+export declare const VInput: DefineComponent<VtInputProps, {
+    focus(): void;
+    blur(): void;
+    select(): void;
+    clear(): void;
+    validate(): boolean;
+    clearValidation(): void;
+    getInputElement(): HTMLInputElement | HTMLTextAreaElement | null;
+    getValidationState(): VtInputValidationResult;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    blur: (event: FocusEvent) => any;
+    change: (event: Event) => any;
+    click: (event: MouseEvent) => any;
+    focus: (event: FocusEvent) => any;
+    input: (event: Event) => any;
+    keydown: (event: KeyboardEvent) => any;
+    keypress: (event: KeyboardEvent) => any;
+    keyup: (event: KeyboardEvent) => any;
+    "update:modelValue": (value: string | number) => any;
+    clear: () => any;
+    validation: (result: VtInputValidationResult) => any;
+}, string, PublicProps, Readonly<VtInputProps> & Readonly<{
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((event: Event) => any) | undefined;
+    onClick?: ((event: MouseEvent) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onInput?: ((event: Event) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+    onKeypress?: ((event: KeyboardEvent) => any) | undefined;
+    onKeyup?: ((event: KeyboardEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    onValidation?: ((result: VtInputValidationResult) => any) | undefined;
+}>, {
+    resize: VtInputResize;
+    type: VtInputType;
+    disabled: boolean;
+    size: VtInputSize;
+    status: VtInputStatus;
+    clearable: boolean;
+    showPassword: boolean;
+    rows: number;
+    autosize: boolean | VtInputAutosizeConfig;
+    validateOnInput: boolean;
+    validateOnBlur: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    textareaRef: HTMLTextAreaElement;
+    inputRef: HTMLInputElement;
+}, HTMLDivElement>;
+
 export declare const VLoader: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLSpanElement>;
 
 export declare const VModal: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;
@@ -636,6 +976,8 @@ export declare interface VModalProps {
 
 export declare type VModalSize = 'small' | 'medium' | 'large';
 
+export declare const VOption: __VLS_WithTemplateSlots_8<typeof __VLS_component_8, __VLS_TemplateResult_8["slots"]>;
+
 export declare const VPagination: DefineComponent<PaginationProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
     "update:currentPage": (page: number) => any;
     "update:pageSize": (size: number) => any;
@@ -653,6 +995,8 @@ export declare const VPagination: DefineComponent<PaginationProps, {}, {}, {}, {
     maxVisiblePages: number;
 }, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
 
+export declare const VSelect: __VLS_WithTemplateSlots_7<typeof __VLS_component_7, __VLS_TemplateResult_7["slots"]>;
+
 export declare const VTable: __VLS_WithTemplateSlots_4<typeof __VLS_component_4, __VLS_TemplateResult_4["slots"]>;
 
 export declare const VTableColumn: DefineComponent<VTableColumnProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<VTableColumnProps> & Readonly<{}>, {
@@ -756,6 +1100,7 @@ export declare interface VTableProps {
     allData?: Record<string, any>[];
     /** Конфігурація колонок */
     columns?: VTableColumnProps[];
+    hideHeader?: boolean;
 }
 
 export declare type VTableRenderSlot = (props: {
@@ -769,6 +1114,192 @@ export declare interface VTableStyleConfig {
     [key: string]: string;
 }
 
+export declare interface VtInputAutosizeConfig {
+    minRows?: number;
+    maxRows?: number;
+}
+
+export declare interface VtInputEmits {
+    'update:modelValue': [value: string | number];
+    input: [event: Event];
+    change: [event: Event];
+    focus: [event: FocusEvent];
+    blur: [event: FocusEvent];
+    clear: [];
+    validation: [result: VtInputValidationResult];
+    keydown: [event: KeyboardEvent];
+    keyup: [event: KeyboardEvent];
+    keypress: [event: KeyboardEvent];
+    click: [event: MouseEvent];
+}
+
+export declare interface VtInputMethods {
+    focus(): void;
+    blur(): void;
+    select(): void;
+    clear(): void;
+    validate(): boolean;
+    clearValidation(): void;
+    getInputElement(): HTMLInputElement | HTMLTextAreaElement | null;
+    getValidationState(): VtInputValidationResult;
+}
+
+export declare interface VtInputProps {
+    modelValue?: string | number;
+    type?: VtInputType;
+    size?: VtInputSize;
+    status?: VtInputStatus;
+    disabled?: boolean;
+    clearable?: boolean;
+    showPassword?: boolean;
+    label?: string;
+    placeholder?: string;
+    helperText?: string;
+    errorMessage?: string;
+    id?: string;
+    name?: string;
+    tabindex?: number;
+    autocomplete?: string;
+    prefixIcon?: IconName;
+    suffixIcon?: IconName;
+    rows?: number;
+    cols?: number;
+    resize?: VtInputResize;
+    autosize?: boolean | VtInputAutosizeConfig;
+    required?: boolean;
+    validateOnInput?: boolean;
+    validateOnBlur?: boolean;
+    showAllErrors?: boolean;
+    requiredMessage?: string;
+    emailMessage?: string;
+    urlMessage?: string;
+    numberMessage?: string;
+    minlengthMessage?: string;
+    maxlengthMessage?: string;
+    minMessage?: string;
+    maxMessage?: string;
+    patternMessage?: string;
+    customValidatorMessage?: string;
+    minlength?: number;
+    maxlength?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    pattern?: string;
+    customValidator?: (value: string | number) => boolean;
+}
+
+export declare type VtInputResize = 'none' | 'both' | 'horizontal' | 'vertical';
+
+export declare type VtInputSize = 'small' | 'medium' | 'large';
+
+export declare type VtInputStatus = 'default' | 'success' | 'error' | 'warning';
+
+export declare type VtInputType = 'text' | 'email' | 'password' | 'number' | 'url' | 'tel' | 'search' | 'textarea';
+
+export declare interface VtInputValidationResult {
+    isValid: boolean;
+    errors: string[];
+}
+
+export declare interface VtOptionEmits {
+    click: [option: VtSelectOption];
+}
+
+export declare interface VtOptionProps {
+    label: string;
+    value: string | number;
+    disabled?: boolean;
+    icon?: string;
+    group?: string;
+}
+
+export declare interface VtSelectContext {
+    selectValue: string | number | Array<string | number>;
+    multiple: boolean;
+    filterable: boolean;
+    filterQuery: string;
+    handleOptionClick: (option: VtSelectOption) => void;
+    isOptionSelected: (value: string | number) => boolean;
+    isOptionVisible: (option: VtSelectOption) => boolean;
+    registerOption: (option: VtSelectOption) => void;
+    unregisterOption: (value: string | number) => void;
+}
+
+export declare const VtSelectContextKey: unique symbol;
+
+export declare interface VtSelectEmits {
+    'update:modelValue': [value: string | number | Array<string | number>];
+    change: [value: string | number | Array<string | number>];
+    focus: [event: FocusEvent];
+    blur: [event: FocusEvent];
+    clear: [];
+    'visible-change': [visible: boolean];
+    'remove-tag': [value: string | number];
+    filter: [query: string];
+    validation: [result: {
+        isValid: boolean;
+        errors: string[];
+    }];
+}
+
+export declare interface VtSelectMethods {
+    focus(): void;
+    blur(): void;
+    clear(): void;
+    validate(): boolean;
+    clearValidation(): void;
+    getSelectedOptions(): VtSelectOption[];
+    getValidationState(): {
+        isValid: boolean;
+        errors: string[];
+    };
+    registerOption(option: VtSelectOption): void;
+    unregisterOption(value: string | number): void;
+}
+
+export declare interface VtSelectOption {
+    label: string;
+    value: string | number;
+    disabled?: boolean;
+    icon?: string;
+    group?: string;
+}
+
+export declare interface VtSelectProps {
+    modelValue?: string | number | Array<string | number>;
+    multiple?: boolean;
+    collapsedTags?: boolean;
+    size?: VtSelectSize;
+    status?: VtSelectStatus;
+    disabled?: boolean;
+    clearable?: boolean;
+    filterable?: boolean;
+    remote?: boolean;
+    loading?: boolean;
+    label?: string;
+    placeholder?: string;
+    helperText?: string;
+    errorMessage?: string;
+    noDataText?: string;
+    noMatchText?: string;
+    loadingText?: string;
+    id?: string;
+    name?: string;
+    tabindex?: number;
+    maxHeight?: number | string;
+    placement?: 'bottom' | 'bottom-start' | 'bottom-end' | 'top' | 'top-start' | 'top-end';
+    filterMethod?: (query: string, option: VtSelectOption) => boolean;
+    required?: boolean;
+    validateOnInput?: boolean;
+    validateOnBlur?: boolean;
+    requiredMessage?: string;
+}
+
+export declare type VtSelectSize = 'small' | 'medium' | 'large';
+
+export declare type VtSelectStatus = 'default' | 'success' | 'error' | 'warning';
+
 declare const VUIPlugin: {
     install(app: App, options?: VUIPluginOptions): void;
 };