import { AllowedComponentProps } from 'vue';
import type BaseButton from 'primevue/button';
import type BaseCard from 'primevue/card';
import type BaseCheckbox from 'primevue/checkbox';
import type BaseContextMenu from 'primevue/contextmenu';
import type BaseDropdown from 'primevue/dropdown';
import type BaseInputNumber from 'primevue/inputnumber';
import type BaseInputSwitch from 'primevue/inputswitch';
import type BaseInputText from 'primevue/inputtext';
import type BaseOverlayPanel from 'primevue/overlaypanel';
import type BasePanel from 'primevue/panel';
import type BaseProgressSpinner from 'primevue/progressspinner';
import type BaseRadioButton from 'primevue/radiobutton';
import type BaseSelectButton from 'primevue/selectbutton';
import type BaseSkeleton from 'primevue/skeleton';
import type BaseTabMenu from 'primevue/tabmenu';
import type BaseTag from 'primevue/tag';
import type BaseTextarea from 'primevue/textarea';
import type { ButtonPassThroughOptions } from 'primevue/button';
import type { CardPassThroughOptions } from 'primevue/card';
import type { CheckboxPassThroughOptions } from 'primevue/checkbox';
import type { CheckboxProps } from 'primevue/checkbox';
import { ComponentCustomProps } from 'vue';
import { ComponentOptionsMixin } from 'vue-demi';
import { ComponentOptionsMixin as ComponentOptionsMixin_2 } from 'vue';
import { ComputedRef } from 'vue-demi';
import { ComputedRef as ComputedRef_2 } from 'vue';
import { Config } from 'tailwindcss/types/config';
import type { ContextMenuPassThroughOptions } from 'primevue/contextmenu';
import type { DataTablePassThroughOptions } from 'primevue/datatable';
import dayjs from 'dayjs';
import { default as default_2 } from 'primevue/datatable';
import { DefineComponent } from 'vue-demi';
import { DefineComponent as DefineComponent_2 } from 'vue';
import type { DropdownPassThroughOptions } from 'primevue/dropdown';
import type { DropdownProps } from 'primevue/dropdown';
import { ExtractPropTypes } from 'vue-demi';
import { ExtractPropTypes as ExtractPropTypes_2 } from 'vue';
import { FormKitFrameworkContext } from '@formkit/core';
import { FormKitTypeDefinition } from '@formkit/core';
import type { GoodsPagingInfoGood } from '@mloyalty/api';
import type { InputMaskPassThroughOptions } from 'primevue/inputmask';
import type { InputNumberPassThroughOptions } from 'primevue/inputnumber';
import type { InputNumberProps } from 'primevue/inputnumber';
import type { InputSwitchPassThroughOptions } from 'primevue/inputswitch';
import type { InputSwitchProps } from 'primevue/inputswitch';
import type { InputTextPassThroughOptions } from 'primevue/inputtext';
import type { InputTextProps } from 'primevue/inputtext';
import { MaybeRef } from 'vue-demi';
import type { Nullable as Nullable_2 } from 'primevue/ts-helpers';
import type { OverlayPanelPassThroughOptions } from 'primevue/overlaypanel';
import type { PaginationArgs } from '@mloyalty/api';
import type { PanelPassThroughOptions } from 'primevue/panel';
import type { PassThroughOptions } from 'primevue/passthrough';
import { PluginCreator } from 'tailwindcss/types/config';
import type PrimeDataTable from 'primevue/datatable';
import type { ProgressSpinnerPassThroughOptions } from 'primevue/progressspinner';
import { PropType } from 'vue-demi';
import { PropType as PropType_2 } from 'vue';
import { PublicProps } from 'vue-demi';
import { PublicProps as PublicProps_2 } from 'vue';
import type { RadioButtonPassThroughOptions } from 'primevue/radiobutton';
import { Ref } from 'vue-demi';
import { Ref as Ref_2 } from 'vue';
import { RendererElement } from 'vue';
import { RendererNode } from 'vue';
import type { SelectButtonPassThroughOptions } from 'primevue/selectbutton';
import type { SelectButtonProps } from 'primevue/selectbutton';
import type { SelectButtonSlots } from 'primevue/selectbutton';
import { ShallowUnwrapRef } from 'vue';
import type { SkeletonPassThroughOptions } from 'primevue/skeleton';
import type { TabMenuPassThroughOptions } from 'primevue/tabmenu';
import type { TagPassThroughOptions } from 'primevue/tag';
import type { TextareaPassThroughOptions } from 'primevue/textarea';
import type { TextareaProps } from 'primevue/textarea';
import type { TooltipDirectivePassThroughOptions } from 'primevue/tooltip';
import { UnwrapRefSimple } from '@vue/reactivity';
import { UseAsyncStateOptions } from '@vueuse/core';
import { VNode } from 'vue';
import { VNodeProps } from 'vue';

declare type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_2<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_3<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_4<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_5<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_6<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_7<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_8<T> = T extends undefined ? never : T;

declare type __VLS_Prettify<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_2<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_3<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_4<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_TypePropsToRuntimeProps<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType_2<__VLS_NonUndefinedable<T[K]>>;
    } : {
        type: PropType_2<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_2<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType_2<__VLS_NonUndefinedable_2<T[K]>>;
    } : {
        type: PropType_2<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_3<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType_2<__VLS_NonUndefinedable_3<T[K]>>;
    } : {
        type: PropType_2<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_4<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType_2<__VLS_NonUndefinedable_4<T[K]>>;
    } : {
        type: PropType_2<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_5<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType_2<__VLS_NonUndefinedable_5<T[K]>>;
    } : {
        type: PropType_2<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_6<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType_2<__VLS_NonUndefinedable_6<T[K]>>;
    } : {
        type: PropType_2<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_7<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType_2<__VLS_NonUndefinedable_7<T[K]>>;
    } : {
        type: PropType_2<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_8<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType_2<__VLS_NonUndefinedable_8<T[K]>>;
    } : {
        type: PropType_2<T[K]>;
        required: true;
    };
};

declare type __VLS_WithDefaults<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_2<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_2<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_3<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_3<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_4<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_4<P[K] & {
        default: D[K];
    }> : P[K];
};

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

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

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

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

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

export declare const Button: typeof BaseButton;

export declare const buttonStyle: ButtonPassThroughOptions;

export declare const Card: typeof BaseCard;

export declare const cardStyle: CardPassThroughOptions;

export declare const Checkbox: typeof BaseCheckbox;

export declare const checkboxDefinition: FormKitTypeDefinition<unknown>;

export declare const checkboxStyle: CheckboxPassThroughOptions;

export declare const checkIfInsideIframe: () => boolean;

export declare const CheckmarkCircleIcon: DefineComponent_2<{}, {}, {}, {}, {}, ComponentOptionsMixin_2, ComponentOptionsMixin_2, {}, string, PublicProps_2, Readonly<ExtractPropTypes_2<{}>>, {}, {}>;

export declare const ColumnHeader: __VLS_WithTemplateSlots_3<DefineComponent<__VLS_TypePropsToRuntimeProps_4<ColumnHeaderProps>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_4<ColumnHeaderProps>>>, {}, {}>, {
    filter?(_: {}): any;
}>;

export declare interface ColumnHeaderProps {
    title: string;
}

export declare const ColumnTextView: DefineComponent<__VLS_TypePropsToRuntimeProps_5<ColumnTextViewProps>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_5<ColumnTextViewProps>>>, {}, {}>;

export declare interface ColumnTextViewProps {
    value: any;
}

export declare const ContextMenu: typeof BaseContextMenu;

export declare const contextMenuStyle: ContextMenuPassThroughOptions;

export declare const Copy: DefineComponent_2<__VLS_TypePropsToRuntimeProps_7<{
    valueClass?: any;
    value?: Nullable<string | number> | undefined;
}>, {}, unknown, {}, {}, ComponentOptionsMixin_2, ComponentOptionsMixin_2, {}, string, PublicProps_2, Readonly<ExtractPropTypes_2<__VLS_TypePropsToRuntimeProps_7<{
    valueClass?: any;
    value?: Nullable<string | number> | undefined;
}>>>, {}, {}>;

export declare const COUNTRY_CODE_PHONE_MASKA = "# (###) ###-##-##";

export declare const DataScrollTable: typeof default_2;

export declare const DataTable: typeof PrimeDataTable;

export declare const DataTablePagination: <T>(__VLS_props: {
    method: UseLoadMoreMethod<T>;
    onFirstLoading?: any;
    asyncStateOptions?: UseAsyncStateOptions<true, T> | undefined;
    effects?: any[] | undefined;
} & VNodeProps & AllowedComponentProps & ComponentCustomProps, __VLS_ctx?: {
    attrs: any;
    slots: {
        default?(_: {
            state: UnwrapRefSimple<T>[];
            isFirstLoading: boolean;
        }): any;
    };
    emit: any;
} | undefined, __VLS_expose?: ((exposed: ShallowUnwrapRef<{
    state: Ref_2<UnwrapRefSimple<T>[]>;
    isLoading: Ref_2<boolean>;
    isFirstLoading: Ref_2<boolean>;
    error: Ref_2<unknown>;
    isLastPage: ComputedRef_2<boolean>;
    loadMore: (delay?: number | undefined, pagination?: any) => Promise<T[] | null>;
    loadDataWithPaginationReset: (delay?: number | undefined, pagination?: any) => Promise<T[] | null>;
}>) => void) | undefined, __VLS_setup?: Promise<{
    props: {
        method: UseLoadMoreMethod<T>;
        onFirstLoading?: any;
        asyncStateOptions?: UseAsyncStateOptions<true, T> | undefined;
        effects?: any[] | undefined;
    } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
    expose(exposed: ShallowUnwrapRef<{
        state: Ref_2<UnwrapRefSimple<T>[]>;
        isLoading: Ref_2<boolean>;
        isFirstLoading: Ref_2<boolean>;
        error: Ref_2<unknown>;
        isLastPage: ComputedRef_2<boolean>;
        loadMore: (delay?: number | undefined, pagination?: any) => Promise<T[] | null>;
        loadDataWithPaginationReset: (delay?: number | undefined, pagination?: any) => Promise<T[] | null>;
    }>): void;
    attrs: any;
    slots: {
        default?(_: {
            state: UnwrapRefSimple<T>[];
            isFirstLoading: boolean;
        }): any;
    };
    emit: any;
}>) => VNode<RendererNode, RendererElement, {
    [key: string]: any;
}> & {
    __ctx?: {
        props: {
            method: UseLoadMoreMethod<T>;
            onFirstLoading?: any;
            asyncStateOptions?: UseAsyncStateOptions<true, T> | undefined;
            effects?: any[] | undefined;
        } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
        expose(exposed: ShallowUnwrapRef<{
            state: Ref_2<UnwrapRefSimple<T>[]>;
            isLoading: Ref_2<boolean>;
            isFirstLoading: Ref_2<boolean>;
            error: Ref_2<unknown>;
            isLastPage: ComputedRef_2<boolean>;
            loadMore: (delay?: number | undefined, pagination?: any) => Promise<T[] | null>;
            loadDataWithPaginationReset: (delay?: number | undefined, pagination?: any) => Promise<T[] | null>;
        }>): void;
        attrs: any;
        slots: {
            default?(_: {
                state: UnwrapRefSimple<T>[];
                isFirstLoading: boolean;
            }): any;
        };
        emit: any;
    } | undefined;
};

export declare const dataTableStyle: DataTablePassThroughOptions;

export declare const DATE_DTO_FORMAT = "YYYY-MM-DDTHH:mm:ss";

export declare const DATE_FORMAT = "DD.MM.YYYY";

export declare const DateView: DefineComponent_2<__VLS_WithDefaults_4<__VLS_TypePropsToRuntimeProps_6<DateViewProps>, {
    template: string;
}>, {}, unknown, {}, {}, ComponentOptionsMixin_2, ComponentOptionsMixin_2, {}, string, PublicProps_2, Readonly<ExtractPropTypes_2<__VLS_WithDefaults_4<__VLS_TypePropsToRuntimeProps_6<DateViewProps>, {
    template: string;
}>>>, {
    template: string;
}, {}>;

export declare interface DateViewProps {
    value: Parameters<typeof dayjs>[0];
    template?: string;
}

declare type DeepNullable<T> = T extends object ? {
    [P in keyof T]: DeepNullable<T[P]>;
} : T | null;

export declare const Dropdown: typeof BaseDropdown;

export declare const dropdownDefinition: FormKitTypeDefinition<unknown>;

export declare const dropdownStyle: DropdownPassThroughOptions;

export declare const FieldsPeriod: __VLS_WithTemplateSlots_4<DefineComponent_2<{}, {}, {}, {}, {}, ComponentOptionsMixin_2, ComponentOptionsMixin_2, {}, string, PublicProps_2, Readonly<ExtractPropTypes_2<{}>>, {}, {}>, {
    from?(_: {}): any;
    to?(_: {}): any;
}>;

export declare type FormKitCheckboxProps = CheckboxProps & {
    value?: CheckboxProps['modelValue'];
    props?: CheckboxProps;
    pt?: CheckboxPassThroughOptions;
    ptOptions?: PassThroughOptions;
};

export declare type FormKitDropdownProps = DropdownProps & {
    size?: 'small' | null;
    value?: DropdownProps['modelValue'];
    pt?: DropdownPassThroughOptions;
    ptOptions?: PassThroughOptions;
};

export declare type FormKitInputCurrencyProps = InputNumberProps & {
    size?: InputTextProps['size'];
    value?: InputNumberProps['modelValue'];
    pt?: InputNumberPassThroughOptions;
    ptOptions?: PassThroughOptions;
};

export declare type FormKitInputDateProps = InputTextProps & {
    value?: Nullable_2<Date | string>;
    pt?: InputTextPassThroughOptions;
    ptOptions?: PassThroughOptions;
};

export declare type FormKitInputNumberProps = InputNumberProps & {
    size?: 'small' | null;
    value?: InputNumberProps['modelValue'];
    pt?: InputNumberPassThroughOptions;
    ptOptions?: PassThroughOptions;
};

export declare type FormKitInputPhoneProps = InputPhoneProps & {
    value?: number | string | null;
    pt?: InputTextPassThroughOptions;
    ptOptions?: PassThroughOptions;
};

export declare type FormKitInputSwitchProps = InputSwitchProps & {
    value?: InputSwitchProps['modelValue'];
    pt?: InputSwitchPassThroughOptions;
    ptOptions?: PassThroughOptions;
};

export declare type FormKitInputTextProps = InputTextProps & {
    value?: Nullable_2<string | number>;
    pt?: InputTextPassThroughOptions;
    ptOptions?: PassThroughOptions;
};

export declare type FormKitPasswordProps = InputTextProps & {
    value?: Nullable_2<string | number>;
    pt?: InputTextPassThroughOptions;
    ptOptions?: PassThroughOptions;
};

export declare type FormKitSelectButtonProps = SelectButtonProps & {
    value?: SelectButtonProps['modelValue'];
    pt?: SelectButtonPassThroughOptions;
    ptOptions?: PassThroughOptions;
};

export declare type FormKitSelectButtonSlots = FormKitFrameworkContext & SelectButtonSlots;

export declare type FormKitTextareaProps = TextareaProps & {
    value?: Nullable<string | number>;
    pt?: TextareaPassThroughOptions;
    ptOptions?: PassThroughOptions;
};

export declare const GoodCard: DefineComponent_2<__VLS_TypePropsToRuntimeProps_8<{
    value: DeepNullable<GoodsPagingInfoGood>;
    showActionMenuBtn?: boolean | undefined;
}>, {}, unknown, {}, {}, ComponentOptionsMixin_2, ComponentOptionsMixin_2, {
    actionMenuClick: (args_0: MouseEvent) => void;
}, string, PublicProps_2, Readonly<ExtractPropTypes_2<__VLS_TypePropsToRuntimeProps_8<{
    value: DeepNullable<GoodsPagingInfoGood>;
    showActionMenuBtn?: boolean | undefined;
}>>> & {
    onActionMenuClick?: ((args_0: MouseEvent) => any) | undefined;
}, {}, {}>;

export declare const ImagePlug: DefineComponent_2<{}, {}, {}, {}, {}, ComponentOptionsMixin_2, ComponentOptionsMixin_2, {}, string, PublicProps_2, Readonly<ExtractPropTypes_2<{}>>, {}, {}>;

export declare const ImageView: DefineComponent_2<__VLS_WithDefaults_3<__VLS_TypePropsToRuntimeProps_3<ImageViewProps>, {
    src: string;
}>, {}, unknown, {}, {}, ComponentOptionsMixin_2, ComponentOptionsMixin_2, {}, string, PublicProps_2, Readonly<ExtractPropTypes_2<__VLS_WithDefaults_3<__VLS_TypePropsToRuntimeProps_3<ImageViewProps>, {
    src: string;
}>>>, {
    src: string;
}, {}>;

export declare interface ImageViewProps {
    src: string;
    imageClass?: any;
}

export declare const inputCurrencyDefinition: FormKitTypeDefinition<unknown>;

export declare const InputDate: DefineComponent<{
    modelValue: PropType<string | null>;
}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<{
    modelValue: PropType<string | null>;
}>>, {}, {}>;

export declare const inputDateDefinition: FormKitTypeDefinition<unknown>;

export declare const InputNumber: typeof BaseInputNumber;

export declare const inputNumberDefinition: FormKitTypeDefinition<unknown>;

export declare const inputNumberStyle: InputNumberPassThroughOptions;

export declare const InputPhone: DefineComponent<{
    modelValue: PropType<string | number | null>;
    disabled: {
        type: PropType<boolean>;
    };
    pt: {
        type: PropType<InputMaskPassThroughOptions>;
    };
    inputId: {
        type: PropType<string>;
    };
    inputClass: {
        type: PropType<any>;
    };
    readonly: {
        type: PropType<boolean>;
    };
    placeholder: {
        type: PropType<any>;
    };
    countryCode: {
        type: PropType<boolean>;
        default: boolean;
    };
    copyButton: {
        type: PropType<boolean>;
        default: boolean;
    };
}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<{
    modelValue: PropType<string | number | null>;
    disabled: {
        type: PropType<boolean>;
    };
    pt: {
        type: PropType<InputMaskPassThroughOptions>;
    };
    inputId: {
        type: PropType<string>;
    };
    inputClass: {
        type: PropType<any>;
    };
    readonly: {
        type: PropType<boolean>;
    };
    placeholder: {
        type: PropType<any>;
    };
    countryCode: {
        type: PropType<boolean>;
        default: boolean;
    };
    copyButton: {
        type: PropType<boolean>;
        default: boolean;
    };
}>>, {
    countryCode: boolean;
    copyButton: boolean;
}, {}>;

export declare const inputPhoneDefinition: FormKitTypeDefinition<unknown>;

export declare interface InputPhoneProps {
    /**
     * Identifier of the focus input to match a label defined for the chips.
     */
    inputId?: string;
    /**
     * Style class of the input field.
     */
    inputClass?: any;
    disabled?: boolean;
    readonly?: boolean;
    placeholder?: any;
    /**
     * @description Отображение префикса кода страны
     * @default true
     */
    countryCode?: boolean;
    /**
     * @description Отобразить кнопку копирования номера телефона
     * @default false
     */
    copyButton?: boolean;
    pt?: InputMaskPassThroughOptions;
}

export declare const InputSwitch: typeof BaseInputSwitch;

export declare const inputSwitchDefinition: FormKitTypeDefinition<unknown>;

export declare const inputSwitchStyle: InputSwitchPassThroughOptions;

export declare const InputText: typeof BaseInputText;

export declare const inputTextDefinition: FormKitTypeDefinition<unknown>;

export declare const inputTextStyle: InputTextPassThroughOptions;

export declare const LoadMorePagination: <T>(__VLS_props: {
    method: UseLoadMoreMethod<T>;
    onFirstLoading?: any;
    asyncStateOptions?: UseAsyncStateOptions<true, T> | undefined;
    effects?: any[] | undefined;
    listClass?: unknown;
} & VNodeProps & AllowedComponentProps & ComponentCustomProps, __VLS_ctx?: {
    attrs: any;
    slots: {
        default?(_: {
            state: UnwrapRefSimple<T>[];
            isFirstLoading: boolean;
        }): any;
        list?(_: {
            key: number;
            data: UnwrapRefSimple<T>;
        }): any;
    };
    emit: any;
} | undefined, __VLS_expose?: ((exposed: ShallowUnwrapRef<{
    state: Ref_2<UnwrapRefSimple<T>[]>;
    isLoading: Ref_2<boolean>;
    isFirstLoading: Ref_2<boolean>;
    error: Ref_2<unknown>;
    isLastPage: ComputedRef_2<boolean>;
    loadMore: (delay?: number | undefined, pagination?: any) => Promise<T[] | null>;
    loadDataWithPaginationReset: (delay?: number | undefined, pagination?: any) => Promise<T[] | null>;
}>) => void) | undefined, __VLS_setup?: Promise<{
    props: {
        method: UseLoadMoreMethod<T>;
        onFirstLoading?: any;
        asyncStateOptions?: UseAsyncStateOptions<true, T> | undefined;
        effects?: any[] | undefined;
        listClass?: unknown;
    } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
    expose(exposed: ShallowUnwrapRef<{
        state: Ref_2<UnwrapRefSimple<T>[]>;
        isLoading: Ref_2<boolean>;
        isFirstLoading: Ref_2<boolean>;
        error: Ref_2<unknown>;
        isLastPage: ComputedRef_2<boolean>;
        loadMore: (delay?: number | undefined, pagination?: any) => Promise<T[] | null>;
        loadDataWithPaginationReset: (delay?: number | undefined, pagination?: any) => Promise<T[] | null>;
    }>): void;
    attrs: any;
    slots: {
        default?(_: {
            state: UnwrapRefSimple<T>[];
            isFirstLoading: boolean;
        }): any;
        list?(_: {
            key: number;
            data: UnwrapRefSimple<T>;
        }): any;
    };
    emit: any;
}>) => VNode<RendererNode, RendererElement, {
    [key: string]: any;
}> & {
    __ctx?: {
        props: {
            method: UseLoadMoreMethod<T>;
            onFirstLoading?: any;
            asyncStateOptions?: UseAsyncStateOptions<true, T> | undefined;
            effects?: any[] | undefined;
            listClass?: unknown;
        } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
        expose(exposed: ShallowUnwrapRef<{
            state: Ref_2<UnwrapRefSimple<T>[]>;
            isLoading: Ref_2<boolean>;
            isFirstLoading: Ref_2<boolean>;
            error: Ref_2<unknown>;
            isLastPage: ComputedRef_2<boolean>;
            loadMore: (delay?: number | undefined, pagination?: any) => Promise<T[] | null>;
            loadDataWithPaginationReset: (delay?: number | undefined, pagination?: any) => Promise<T[] | null>;
        }>): void;
        attrs: any;
        slots: {
            default?(_: {
                state: UnwrapRefSimple<T>[];
                isFirstLoading: boolean;
            }): any;
            list?(_: {
                key: number;
                data: UnwrapRefSimple<T>;
            }): any;
        };
        emit: any;
    } | undefined;
};

export declare const locales: {
    ru: {
        startsWith: string;
        contains: string;
        notContains: string;
        endsWith: string;
        equals: string;
        notEquals: string;
        noFilter: string;
        filter: string;
        lt: string;
        lte: string;
        gt: string;
        gte: string;
        dateIs: string;
        dateIsNot: string;
        dateBefore: string;
        dateAfter: string;
        custom: string;
        clear: string;
        apply: string;
        matchAll: string;
        matchAny: string;
        addRule: string;
        removeRule: string;
        accept: string;
        reject: string;
        choose: string;
        upload: string;
        cancel: string;
        completed: string;
        pending: string;
        dayNames: string[];
        dayNamesShort: string[];
        dayNamesMin: string[];
        monthNames: string[];
        monthNamesShort: string[];
        chooseYear: string;
        chooseMonth: string;
        chooseDate: string;
        prevDecade: string;
        nextDecade: string;
        prevYear: string;
        nextYear: string;
        prevMonth: string;
        nextMonth: string;
        prevHour: string;
        nextHour: string;
        prevMinute: string;
        nextMinute: string;
        prevSecond: string;
        nextSecond: string;
        am: string;
        pm: string;
        today: string;
        weekHeader: string;
        firstDayOfWeek: number;
        dateFormat: string;
        weak: string;
        medium: string;
        strong: string;
        passwordPrompt: string;
        emptyFilterMessage: string;
        searchMessage: string;
        selectionMessage: string;
        emptySelectionMessage: string;
        emptySearchMessage: string;
        emptyMessage: string;
        aria: {
            trueLabel: string;
            falseLabel: string;
            nullLabel: string;
            star: string;
            stars: string;
            selectAll: string;
            unselectAll: string;
            close: string;
            previous: string;
            next: string;
            navigation: string;
            scrollTop: string;
            moveTop: string;
            moveUp: string;
            moveDown: string;
            moveBottom: string;
            moveToTarget: string;
            moveToSource: string;
            moveAllToTarget: string;
            moveAllToSource: string;
            pageLabel: string;
            firstPageLabel: string;
            lastPageLabel: string;
            nextPageLabel: string;
            previousPageLabel: string;
            rowsPerPageLabel: string;
            jumpToPageDropdownLabel: string;
            jumpToPageInputLabel: string;
            selectRow: string;
            unselectRow: string;
            expandRow: string;
            collapseRow: string;
            showFilterMenu: string;
            hideFilterMenu: string;
            filterOperator: string;
            filterConstraint: string;
            editRow: string;
            saveEdit: string;
            cancelEdit: string;
            listView: string;
            gridView: string;
            slide: string;
            slideNumber: string;
            zoomImage: string;
            zoomIn: string;
            zoomOut: string;
            rotateRight: string;
            rotateLeft: string;
        };
    };
};

export declare const NATIONAL_PHONE_MASKA = "(###) ###-##-##";

export declare const NoDataView: __VLS_WithTemplateSlots_5<DefineComponent_2<{}, {}, {}, {}, {}, ComponentOptionsMixin_2, ComponentOptionsMixin_2, {}, string, PublicProps_2, Readonly<ExtractPropTypes_2<{}>>, {}, {}>, {
    default?(_: {}): any;
}>;

declare type Nullable<T> = T | null;

export declare const OverlayPanel: typeof BaseOverlayPanel;

export declare const overlayPanelStyle: OverlayPanelPassThroughOptions;

export declare const Panel: typeof BasePanel;

export declare const panelStyle: PanelPassThroughOptions;

export declare const passwordDefinition: FormKitTypeDefinition<unknown>;

export declare const PhoneView: __VLS_WithTemplateSlots<DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PhoneViewProps>, {
    value: string;
    countryCode: boolean;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PhoneViewProps>, {
    value: string;
    countryCode: boolean;
}>>>, {
    value: Nullable_2<string | number>;
    countryCode: boolean;
}, {}>, {
    default?(_: {
        maskedValue: string;
    }): any;
}>;

export declare interface PhoneViewProps {
    value: Nullable_2<number | string>;
    /**
     * @description Отображение префикса кода страны
     * @default true
     */
    countryCode?: boolean;
    /**
     * @description Включить копирование по клику
     * @default true
     */
    copy?: boolean;
    /**
     * @description Откроет вызов телефона при клике
     * @default true
     */
    link?: boolean;
}

export declare const PictureGallery: <T>(__VLS_props: {
    value?: T[] | undefined;
    srcKey?: Extract<keyof T, string> | ((item: T) => string) | undefined;
    swiperClass?: any;
} & VNodeProps & AllowedComponentProps & ComponentCustomProps, __VLS_ctx?: {
    attrs: any;
    slots: {};
    emit: any;
} | undefined, __VLS_expose?: ((exposed: ShallowUnwrapRef<{}>) => void) | undefined, __VLS_setup?: Promise<{
    props: {
        value?: T[] | undefined;
        srcKey?: Extract<keyof T, string> | ((item: T) => string) | undefined;
        swiperClass?: any;
    } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
    expose(exposed: ShallowUnwrapRef<{}>): void;
    attrs: any;
    slots: {};
    emit: any;
}>) => VNode<RendererNode, RendererElement, {
    [key: string]: any;
}> & {
    __ctx?: {
        props: {
            value?: T[] | undefined;
            srcKey?: Extract<keyof T, string> | ((item: T) => string) | undefined;
            swiperClass?: any;
        } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
        expose(exposed: ShallowUnwrapRef<{}>): void;
        attrs: any;
        slots: {};
        emit: any;
    } | undefined;
};

export declare const preset: {
    theme: {
        colors: {
            transparent: string;
            current: string;
            black: string;
            white: string;
            red: string;
            yellow: {
                DEFAULT: string;
                action: string;
            };
            blue: string;
            green: string;
            gray: string;
            content: string;
            primary: {
                DEFAULT: string;
                button: string;
            };
            secondary: string;
            checkbox: string;
            radio: string;
            panel: string;
            slate: {
                50: string;
                100: string;
                200: string;
                300: string;
                400: string;
                500: string;
                600: string;
                700: string;
                800: string;
                900: string;
                1000: string;
                1100: string;
                1200: string;
                1300: string;
            };
        };
        extend: {
            fontFamily: {
                sans: [string, ...string[]];
            };
            textColor: {
                primary: {
                    DEFAULT: string;
                };
                secondary: string;
            };
            borderRadius: {
                primary: string;
            };
            backgroundImage: {
                'mloyalty-icon': string;
            };
        };
    };
    plugins: {
        handler: PluginCreator;
        config?: Partial<Config> | undefined;
    }[];
};

export declare interface PrimeWrapper<T extends abstract new (...args: any) => any> {
    primeComponent?: InstanceType<T>;
}

export declare const ProgressSpinner: typeof BaseProgressSpinner;

export declare const progressSpinnerStyle: ProgressSpinnerPassThroughOptions;

export declare const RadioButton: typeof BaseRadioButton;

export declare const radioButtonStyle: RadioButtonPassThroughOptions;

export declare const ResultView: __VLS_WithTemplateSlots_2<DefineComponent<__VLS_WithDefaults_2<__VLS_TypePropsToRuntimeProps_2<ResultViewProps>, {
    loading: boolean;
    description: string;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_2<__VLS_TypePropsToRuntimeProps_2<ResultViewProps>, {
    loading: boolean;
    description: string;
}>>>, {
    loading: boolean;
}, {}>, {
    default?(_: {}): any;
}>;

export declare interface ResultViewProps {
    /**
     * Состояние загрузки, когда true отображает лоадер
     */
    loading?: boolean;
    error?: unknown;
    /**
     * Пользовательское условие, при котором отображается ошибка
     */
    showError?: boolean;
}

export declare const rub: Intl.NumberFormat;

export declare const SelectButton: typeof BaseSelectButton;

export declare const selectButtonDefinition: FormKitTypeDefinition<unknown>;

export declare const selectButtonStyle: SelectButtonPassThroughOptions;

export declare const Skeleton: typeof BaseSkeleton;

export declare const skeletonStyle: SkeletonPassThroughOptions;

export declare const SuccessIcon: DefineComponent_2<{}, {}, {}, {}, {}, ComponentOptionsMixin_2, ComponentOptionsMixin_2, {}, string, PublicProps_2, Readonly<ExtractPropTypes_2<{}>>, {}, {}>;

export declare const TabMenu: typeof BaseTabMenu;

export declare const tabMenuStyle: TabMenuPassThroughOptions;

export declare const Tag: typeof BaseTag;

export declare const tagStyle: TagPassThroughOptions;

export declare const Textarea: typeof BaseTextarea;

export declare const textareaDefinition: FormKitTypeDefinition<unknown>;

export declare const textareaStyle: TextareaPassThroughOptions;

export declare const tooltipStyle: TooltipDirectivePassThroughOptions;

export declare const useDataTableFilters: <T extends Record<string, any>>(schema: T) => {
    filters: Ref<T>;
    filledFilters: ComputedRef<any>;
};

export declare const useLoadMore: <T = any, Shallow extends boolean = true>(options: UseLoadMoreOptions<T, Shallow>) => {
    /**
     * Массив всех загруженных данных
     */
    state: Ref<UnwrapRefSimple<T>[]>;
    /**
     * Данные, полученные с последнего запроса
     */
    lastRequestData: Shallow extends true ? Ref<T[] | null> : Ref<UnwrapRefSimple<T>[] | null>;
    /**
     * Статус подгрузки данных
     */
    isLoading: Ref<boolean>;
    /**
     * Статус, что загрузка данных выполняется "с нуля"
     */
    isFirstLoading: Ref<boolean>;
    isLastPage: ComputedRef<boolean>;
    /**
     * Количество записей всего
     */
    rows: Ref<number>;
    error: Ref<unknown>;
    loadMore: (delay?: number | undefined, pagination?: any) => Promise<T[] | null>;
    loadDataWithPaginationReset: (delay?: number | undefined, pagination?: any) => Promise<T[] | null>;
};

export declare type UseLoadMoreMethod<T> = (args: PaginationArgs & Record<string, any>) => UseLoadMoreMethodReturnData<T> | Promise<UseLoadMoreMethodReturnData<T>>;

export declare type UseLoadMoreMethodReturnData<T> = {
    /**
     * Отображаемые данные
     */
    data: T[];
    /**
     * Кол-во данных(строк) в API
     */
    rows: Nullable<number>;
};

export declare type UseLoadMoreOptions<T = any, Shallow extends boolean = true> = {
    method: UseLoadMoreMethod<T>;
    onFirstLoading?: any;
    asyncStateOptions?: UseAsyncStateOptions<Shallow, T>;
    effects?: MaybeRef<any>[];
};

export { }