import type { z } from 'zod';
import type { Kotti } from '../types';
import { KottiFieldToggle, KottiFieldToggleGroup } from './types';
export declare const KtFieldToggle: {
    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
        dataTest: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        type: Omit<import("vue").Prop<"switch" | "checkbox" | Kotti.FieldToggle.Shared.Type>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<"switch" | "checkbox" | Kotti.FieldToggle.Shared.Type>;
        } & {
            default: () => "switch" | "checkbox" | Kotti.FieldToggle.Shared.Type;
        };
        label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        size: Omit<import("vue").Prop<"large" | "medium" | "small" | Kotti.Field.Size | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<"large" | "medium" | "small" | Kotti.Field.Size | null>;
        } & {
            default: () => "large" | "medium" | "small" | Kotti.Field.Size | null;
        };
        isDisabled: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        isLoading: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        tabIndex: Omit<import("vue").Prop<number>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<number>;
        } & {
            default: () => number;
        };
        placeholder: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        hideClear: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        hideValidation: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        showVisibilityToggle: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        isBorderless: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        formKey: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        leftIcon: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        isOptional: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        rightIcon: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        prefix: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        suffix: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        validator: Omit<import("vue").Prop<(args_0: any, ...args: unknown[]) => {
            type: "empty";
        } | {
            type: "error";
            text: string | null;
        } | {
            type: "success";
            text: string | null;
        } | {
            type: "warning";
            text: string | null;
        }>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<(args_0: any, ...args: unknown[]) => {
                type: "empty";
            } | {
                type: "error";
                text: string | null;
            } | {
                type: "success";
                text: string | null;
            } | {
                type: "warning";
                text: string | null;
            }>;
        } & {
            default: () => (args_0: any, ...args: unknown[]) => {
                type: "empty";
            } | {
                type: "error";
                text: string | null;
            } | {
                type: "success";
                text: string | null;
            } | {
                type: "warning";
                text: string | null;
            };
        };
        modelValue: Omit<import("vue").Prop<boolean | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean | null>;
        } & {
            default: () => boolean | null;
        };
    }>> & Readonly<{
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    }>, {
        fieldProps: import("vue").ComputedRef<{
            helpText: string | null;
            label: string | null;
            size: "large" | "medium" | "small" | Kotti.Field.Size | null;
            isDisabled: boolean;
            isLoading: boolean;
            hideClear: any;
            hideValidation: boolean;
            showVisibilityToggle: boolean;
            isBorderless: any;
            helpDescription: string | null;
            leftIcon: any;
            isOptional: boolean;
            rightIcon: any;
            prefix: any;
            suffix: any;
            currentValue: boolean | null;
            hasClear: boolean;
            inputProps: Readonly<{
                "data-test": string;
                disabled: boolean;
                id: string;
                tabindex: number;
            }>;
            isEmpty: boolean;
            setValue(newValue: boolean | null, options?: {
                forceUpdate: boolean;
            }): void;
            validation: Readonly<{
                type: "empty";
            } | {
                type: "error";
                text: string | null;
            } | {
                type: "success";
                text: string | null;
            } | {
                type: "warning";
                text: string | null;
            }>;
        }>;
        hasHelpText: import("vue").ComputedRef<boolean>;
        iconClasses: import("vue").ComputedRef<(element: string, modifications: string[]) => string[]>;
        inputProps: import("vue").ComputedRef<{
            forceUpdateKey: number;
            'data-test': string;
            disabled: boolean;
            id: string;
            tabindex: number;
        }>;
        labelSuffix: import("vue").ComputedRef<"*" | null>;
        labelSuffixClasses: import("vue").ComputedRef<{
            'kt-field__header__label__suffix': boolean;
            'kt-field__header__label__suffix--error': boolean;
        }>;
        onInput: (newValue: boolean | undefined) => void;
        showHelpTextAsInnerSuffix: import("vue").ComputedRef<boolean>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], import("vue").PublicProps, {
        dataTest: string | null;
        type: "switch" | "checkbox" | Kotti.FieldToggle.Shared.Type;
        label: string | null;
        size: "large" | "medium" | "small" | Kotti.Field.Size | null;
        isDisabled: boolean;
        isLoading: boolean;
        helpText: string | null;
        tabIndex: number;
        modelValue: boolean | null;
        hideValidation: boolean;
        showVisibilityToggle: boolean;
        inputId: string | null;
        formKey: string | null;
        helpDescription: string | null;
        isOptional: boolean;
        validator: (args_0: any, ...args: unknown[]) => {
            type: "empty";
        } | {
            type: "error";
            text: string | null;
        } | {
            type: "success";
            text: string | null;
        } | {
            type: "warning";
            text: string | null;
        };
    }, true, {}, {}, {
        FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            helpText: {
                default: null;
                type: import("vue").PropType<string | null>;
            };
            helpTextSlot: {
                default: undefined;
                type: import("vue").PropType<import("vue").Slot<undefined>>;
            };
        }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            helpText: {
                default: null;
                type: import("vue").PropType<string | null>;
            };
            helpTextSlot: {
                default: undefined;
                type: import("vue").PropType<import("vue").Slot<undefined>>;
            };
        }>> & Readonly<{}>, {
            helpText: string | null;
            helpTextSlot: import("vue").Slot<undefined>;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        KtField: {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                debounceLabelClick: {
                    default: boolean;
                    type: BooleanConstructor;
                };
                field: {
                    required: true;
                    type: import("vue").PropType<Kotti.Field.Hook.Returns<unknown>>;
                };
                getEmptyValue: {
                    default: null;
                    type: import("vue").PropType<() => unknown>;
                };
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
                isRange: {
                    default: boolean;
                    type: BooleanConstructor;
                };
                useFieldset: {
                    default: boolean;
                    type: BooleanConstructor;
                };
            }>> & Readonly<{
                onClick?: ((...args: any[]) => any) | undefined;
                onMousedown?: ((...args: any[]) => any) | undefined;
                onVisibilityChange?: ((...args: any[]) => any) | undefined;
            }>, {
                affixClasses: import("vue").ComputedRef<(modifications: string[]) => string[]>;
                focusInput: () => void;
                handleClear: () => void;
                handleVisibilityChange: () => void;
                iconClasses: import("vue").ComputedRef<(element: string, modifications: string[]) => string[]>;
                inputId: import("vue").ComputedRef<string>;
                inputContainerRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
                inputContainerWrapperRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
                onClickLabel: (event: MouseEvent) => void;
                showLabel: import("vue").ComputedRef<true | import("vue").Slot<undefined> | undefined>;
                showValidation: import("vue").ComputedRef<boolean>;
                validationState: import("vue").ComputedRef<"error" | "empty">;
                validationText: import("vue").ComputedRef<string | null>;
                validationTextIcon: import("vue").ComputedRef<import("@3yourmind/yoco").Yoco.Icon | null>;
                valueVisibility: import("vue").Ref<boolean, boolean>;
                wrapperClasses: import("vue").ComputedRef<string[]>;
                Yoco: typeof import("@3yourmind/yoco").Yoco;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "mousedown" | "visibilityChange")[], import("vue").PublicProps, {
                helpTextSlot: import("vue").Slot<undefined>;
                debounceLabelClick: boolean;
                getEmptyValue: () => unknown;
                isRange: boolean;
                useFieldset: boolean;
            }, true, {}, {}, {
                FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    helpText: {
                        default: null;
                        type: import("vue").PropType<string | null>;
                    };
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    helpText: {
                        default: null;
                        type: import("vue").PropType<string | null>;
                    };
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                }>> & Readonly<{}>, {
                    helpText: string | null;
                    helpTextSlot: import("vue").Slot<undefined>;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                KtLabel: {
                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                        helpTextSlot: {
                            default: undefined;
                            type: import("vue").PropType<import("vue").Slot<undefined>>;
                        };
                        label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<string | null>;
                        } & {
                            default: () => string | null;
                        };
                        helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<string | null>;
                        } & {
                            default: () => string | null;
                        };
                        helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<string | null>;
                        } & {
                            default: () => string | null;
                        };
                        inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<string | null>;
                        } & {
                            default: () => string | null;
                        };
                        isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<boolean>;
                        } & {
                            default: () => boolean;
                        };
                        validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                        } & {
                            default: () => "error" | "success" | "warning" | "empty";
                        };
                    }>> & Readonly<{
                        onClick?: ((...args: any[]) => any) | undefined;
                    }>, {
                        hasHelpText: import("vue").ComputedRef<boolean>;
                        labelSuffix: import("vue").ComputedRef<"*" | null>;
                        labelSuffixClasses: import("vue").ComputedRef<{
                            [x: string]: boolean;
                            'kt-label__header-label-suffix': boolean;
                        }>;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], import("vue").PublicProps, {
                        label: string | null;
                        helpText: string | null;
                        inputId: string | null;
                        helpDescription: string | null;
                        helpTextSlot: import("vue").Slot<undefined>;
                        isRequired: boolean;
                        validationState: "error" | "success" | "warning" | "empty";
                    }, true, {}, {}, {
                        FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                            helpText: {
                                default: null;
                                type: import("vue").PropType<string | null>;
                            };
                            helpTextSlot: {
                                default: undefined;
                                type: import("vue").PropType<import("vue").Slot<undefined>>;
                            };
                        }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                            helpText: {
                                default: null;
                                type: import("vue").PropType<string | null>;
                            };
                            helpTextSlot: {
                                default: undefined;
                                type: import("vue").PropType<import("vue").Slot<undefined>>;
                            };
                        }>> & Readonly<{}>, {
                            helpText: string | null;
                            helpTextSlot: import("vue").Slot<undefined>;
                        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import("vue").ExtractPropTypes<{
                        helpTextSlot: {
                            default: undefined;
                            type: import("vue").PropType<import("vue").Slot<undefined>>;
                        };
                        label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<string | null>;
                        } & {
                            default: () => string | null;
                        };
                        helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<string | null>;
                        } & {
                            default: () => string | null;
                        };
                        helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<string | null>;
                        } & {
                            default: () => string | null;
                        };
                        inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<string | null>;
                        } & {
                            default: () => string | null;
                        };
                        isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<boolean>;
                        } & {
                            default: () => boolean;
                        };
                        validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                        } & {
                            default: () => "error" | "success" | "warning" | "empty";
                        };
                    }>> & Readonly<{
                        onClick?: ((...args: any[]) => any) | undefined;
                    }>, {
                        hasHelpText: import("vue").ComputedRef<boolean>;
                        labelSuffix: import("vue").ComputedRef<"*" | null>;
                        labelSuffixClasses: import("vue").ComputedRef<{
                            [x: string]: boolean;
                            'kt-label__header-label-suffix': boolean;
                        }>;
                    }, {}, {}, {}, {
                        label: string | null;
                        helpText: string | null;
                        inputId: string | null;
                        helpDescription: string | null;
                        helpTextSlot: import("vue").Slot<undefined>;
                        isRequired: boolean;
                        validationState: "error" | "success" | "warning" | "empty";
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                    label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<boolean>;
                    } & {
                        default: () => boolean;
                    };
                    validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                    } & {
                        default: () => "error" | "success" | "warning" | "empty";
                    };
                }>> & Readonly<{
                    onClick?: ((...args: any[]) => any) | undefined;
                }>, {
                    hasHelpText: import("vue").ComputedRef<boolean>;
                    labelSuffix: import("vue").ComputedRef<"*" | null>;
                    labelSuffixClasses: import("vue").ComputedRef<{
                        [x: string]: boolean;
                        'kt-label__header-label-suffix': boolean;
                    }>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", {
                    label: string | null;
                    helpText: string | null;
                    inputId: string | null;
                    helpDescription: string | null;
                    helpTextSlot: import("vue").Slot<undefined>;
                    isRequired: boolean;
                    validationState: "error" | "success" | "warning" | "empty";
                }, {}, string, {}, {
                    FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        helpText: {
                            default: null;
                            type: import("vue").PropType<string | null>;
                        };
                        helpTextSlot: {
                            default: undefined;
                            type: import("vue").PropType<import("vue").Slot<undefined>>;
                        };
                    }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                        [key: string]: any;
                    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        helpText: {
                            default: null;
                            type: import("vue").PropType<string | null>;
                        };
                        helpTextSlot: {
                            default: undefined;
                            type: import("vue").PropType<import("vue").Slot<undefined>>;
                        };
                    }>> & Readonly<{}>, {
                        helpText: string | null;
                        helpTextSlot: import("vue").Slot<undefined>;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                    install: import("vue").FunctionPlugin<Record<string, never>>;
                } & {
                    meta: Kotti.Meta<z.ZodObject<{
                        label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                        helpText: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                        helpDescription: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                        inputId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                        isRequired: z.ZodDefault<z.ZodBoolean>;
                        validationState: z.ZodDefault<z.ZodEnum<["empty", "error", "success", "warning"]>>;
                    }, "strip", z.ZodTypeAny, {
                        label: string | null;
                        helpText: string | null;
                        inputId: string | null;
                        helpDescription: string | null;
                        isRequired: boolean;
                        validationState: "error" | "success" | "warning" | "empty";
                    }, {
                        label?: string | null | undefined;
                        helpText?: string | null | undefined;
                        helpDescription?: string | null | undefined;
                        inputId?: string | null | undefined;
                        isRequired?: boolean | undefined;
                        validationState?: "error" | "success" | "warning" | "empty" | undefined;
                    }>> & Record<string, unknown>;
                };
                KtLoading: {
                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                        type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                        } & {
                            default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                        };
                    }>> & Readonly<{}>, {
                        loadingClasses: import("vue").ComputedRef<string>;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
                        type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import("vue").ExtractPropTypes<{
                        type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                        } & {
                            default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                        };
                    }>> & Readonly<{}>, {
                        loadingClasses: import("vue").ComputedRef<string>;
                    }, {}, {}, {}, {
                        type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                    type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                    } & {
                        default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                    };
                }>> & Readonly<{}>, {
                    loadingClasses: import("vue").ComputedRef<string>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
                    type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                    install: import("vue").FunctionPlugin<Record<string, never>>;
                } & {
                    meta: Kotti.Meta<z.ZodObject<{
                        type: z.ZodDefault<z.ZodEnum<["circle", "rectangle", "rectangle-lg", "rectangle-md", "rectangle-sm", "square"]>>;
                    }, "strip", z.ZodTypeAny, {
                        type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                    }, {
                        type?: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square" | undefined;
                    }>> & Record<string, unknown>;
                };
            } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("vue").ExtractPropTypes<{
                debounceLabelClick: {
                    default: boolean;
                    type: BooleanConstructor;
                };
                field: {
                    required: true;
                    type: import("vue").PropType<Kotti.Field.Hook.Returns<unknown>>;
                };
                getEmptyValue: {
                    default: null;
                    type: import("vue").PropType<() => unknown>;
                };
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
                isRange: {
                    default: boolean;
                    type: BooleanConstructor;
                };
                useFieldset: {
                    default: boolean;
                    type: BooleanConstructor;
                };
            }>> & Readonly<{
                onClick?: ((...args: any[]) => any) | undefined;
                onMousedown?: ((...args: any[]) => any) | undefined;
                onVisibilityChange?: ((...args: any[]) => any) | undefined;
            }>, {
                affixClasses: import("vue").ComputedRef<(modifications: string[]) => string[]>;
                focusInput: () => void;
                handleClear: () => void;
                handleVisibilityChange: () => void;
                iconClasses: import("vue").ComputedRef<(element: string, modifications: string[]) => string[]>;
                inputId: import("vue").ComputedRef<string>;
                inputContainerRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
                inputContainerWrapperRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
                onClickLabel: (event: MouseEvent) => void;
                showLabel: import("vue").ComputedRef<true | import("vue").Slot<undefined> | undefined>;
                showValidation: import("vue").ComputedRef<boolean>;
                validationState: import("vue").ComputedRef<"error" | "empty">;
                validationText: import("vue").ComputedRef<string | null>;
                validationTextIcon: import("vue").ComputedRef<import("@3yourmind/yoco").Yoco.Icon | null>;
                valueVisibility: import("vue").Ref<boolean, boolean>;
                wrapperClasses: import("vue").ComputedRef<string[]>;
                Yoco: typeof import("@3yourmind/yoco").Yoco;
            }, {}, {}, {}, {
                helpTextSlot: import("vue").Slot<undefined>;
                debounceLabelClick: boolean;
                getEmptyValue: () => unknown;
                isRange: boolean;
                useFieldset: boolean;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            debounceLabelClick: {
                default: boolean;
                type: BooleanConstructor;
            };
            field: {
                required: true;
                type: import("vue").PropType<Kotti.Field.Hook.Returns<unknown>>;
            };
            getEmptyValue: {
                default: null;
                type: import("vue").PropType<() => unknown>;
            };
            helpTextSlot: {
                default: undefined;
                type: import("vue").PropType<import("vue").Slot<undefined>>;
            };
            isRange: {
                default: boolean;
                type: BooleanConstructor;
            };
            useFieldset: {
                default: boolean;
                type: BooleanConstructor;
            };
        }>> & Readonly<{
            onClick?: ((...args: any[]) => any) | undefined;
            onMousedown?: ((...args: any[]) => any) | undefined;
            onVisibilityChange?: ((...args: any[]) => any) | undefined;
        }>, {
            affixClasses: import("vue").ComputedRef<(modifications: string[]) => string[]>;
            focusInput: () => void;
            handleClear: () => void;
            handleVisibilityChange: () => void;
            iconClasses: import("vue").ComputedRef<(element: string, modifications: string[]) => string[]>;
            inputId: import("vue").ComputedRef<string>;
            inputContainerRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
            inputContainerWrapperRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
            onClickLabel: (event: MouseEvent) => void;
            showLabel: import("vue").ComputedRef<true | import("vue").Slot<undefined> | undefined>;
            showValidation: import("vue").ComputedRef<boolean>;
            validationState: import("vue").ComputedRef<"error" | "empty">;
            validationText: import("vue").ComputedRef<string | null>;
            validationTextIcon: import("vue").ComputedRef<import("@3yourmind/yoco").Yoco.Icon | null>;
            valueVisibility: import("vue").Ref<boolean, boolean>;
            wrapperClasses: import("vue").ComputedRef<string[]>;
            Yoco: typeof import("@3yourmind/yoco").Yoco;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "mousedown" | "visibilityChange")[], "click" | "mousedown" | "visibilityChange", {
            helpTextSlot: import("vue").Slot<undefined>;
            debounceLabelClick: boolean;
            getEmptyValue: () => unknown;
            isRange: boolean;
            useFieldset: boolean;
        }, {}, string, {}, {
            FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                helpText: {
                    default: null;
                    type: import("vue").PropType<string | null>;
                };
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
            }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                [key: string]: any;
            }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                helpText: {
                    default: null;
                    type: import("vue").PropType<string | null>;
                };
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
            }>> & Readonly<{}>, {
                helpText: string | null;
                helpTextSlot: import("vue").Slot<undefined>;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            KtLabel: {
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                    label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<boolean>;
                    } & {
                        default: () => boolean;
                    };
                    validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                    } & {
                        default: () => "error" | "success" | "warning" | "empty";
                    };
                }>> & Readonly<{
                    onClick?: ((...args: any[]) => any) | undefined;
                }>, {
                    hasHelpText: import("vue").ComputedRef<boolean>;
                    labelSuffix: import("vue").ComputedRef<"*" | null>;
                    labelSuffixClasses: import("vue").ComputedRef<{
                        [x: string]: boolean;
                        'kt-label__header-label-suffix': boolean;
                    }>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], import("vue").PublicProps, {
                    label: string | null;
                    helpText: string | null;
                    inputId: string | null;
                    helpDescription: string | null;
                    helpTextSlot: import("vue").Slot<undefined>;
                    isRequired: boolean;
                    validationState: "error" | "success" | "warning" | "empty";
                }, true, {}, {}, {
                    FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        helpText: {
                            default: null;
                            type: import("vue").PropType<string | null>;
                        };
                        helpTextSlot: {
                            default: undefined;
                            type: import("vue").PropType<import("vue").Slot<undefined>>;
                        };
                    }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                        [key: string]: any;
                    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        helpText: {
                            default: null;
                            type: import("vue").PropType<string | null>;
                        };
                        helpTextSlot: {
                            default: undefined;
                            type: import("vue").PropType<import("vue").Slot<undefined>>;
                        };
                    }>> & Readonly<{}>, {
                        helpText: string | null;
                        helpTextSlot: import("vue").Slot<undefined>;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import("vue").ExtractPropTypes<{
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                    label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<boolean>;
                    } & {
                        default: () => boolean;
                    };
                    validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                    } & {
                        default: () => "error" | "success" | "warning" | "empty";
                    };
                }>> & Readonly<{
                    onClick?: ((...args: any[]) => any) | undefined;
                }>, {
                    hasHelpText: import("vue").ComputedRef<boolean>;
                    labelSuffix: import("vue").ComputedRef<"*" | null>;
                    labelSuffixClasses: import("vue").ComputedRef<{
                        [x: string]: boolean;
                        'kt-label__header-label-suffix': boolean;
                    }>;
                }, {}, {}, {}, {
                    label: string | null;
                    helpText: string | null;
                    inputId: string | null;
                    helpDescription: string | null;
                    helpTextSlot: import("vue").Slot<undefined>;
                    isRequired: boolean;
                    validationState: "error" | "success" | "warning" | "empty";
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
                label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<boolean>;
                } & {
                    default: () => boolean;
                };
                validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                } & {
                    default: () => "error" | "success" | "warning" | "empty";
                };
            }>> & Readonly<{
                onClick?: ((...args: any[]) => any) | undefined;
            }>, {
                hasHelpText: import("vue").ComputedRef<boolean>;
                labelSuffix: import("vue").ComputedRef<"*" | null>;
                labelSuffixClasses: import("vue").ComputedRef<{
                    [x: string]: boolean;
                    'kt-label__header-label-suffix': boolean;
                }>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", {
                label: string | null;
                helpText: string | null;
                inputId: string | null;
                helpDescription: string | null;
                helpTextSlot: import("vue").Slot<undefined>;
                isRequired: boolean;
                validationState: "error" | "success" | "warning" | "empty";
            }, {}, string, {}, {
                FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    helpText: {
                        default: null;
                        type: import("vue").PropType<string | null>;
                    };
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    helpText: {
                        default: null;
                        type: import("vue").PropType<string | null>;
                    };
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                }>> & Readonly<{}>, {
                    helpText: string | null;
                    helpTextSlot: import("vue").Slot<undefined>;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                install: import("vue").FunctionPlugin<Record<string, never>>;
            } & {
                meta: Kotti.Meta<z.ZodObject<{
                    label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    helpText: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    helpDescription: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    inputId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    isRequired: z.ZodDefault<z.ZodBoolean>;
                    validationState: z.ZodDefault<z.ZodEnum<["empty", "error", "success", "warning"]>>;
                }, "strip", z.ZodTypeAny, {
                    label: string | null;
                    helpText: string | null;
                    inputId: string | null;
                    helpDescription: string | null;
                    isRequired: boolean;
                    validationState: "error" | "success" | "warning" | "empty";
                }, {
                    label?: string | null | undefined;
                    helpText?: string | null | undefined;
                    helpDescription?: string | null | undefined;
                    inputId?: string | null | undefined;
                    isRequired?: boolean | undefined;
                    validationState?: "error" | "success" | "warning" | "empty" | undefined;
                }>> & Record<string, unknown>;
            };
            KtLoading: {
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                    type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                    } & {
                        default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                    };
                }>> & Readonly<{}>, {
                    loadingClasses: import("vue").ComputedRef<string>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
                    type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import("vue").ExtractPropTypes<{
                    type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                    } & {
                        default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                    };
                }>> & Readonly<{}>, {
                    loadingClasses: import("vue").ComputedRef<string>;
                }, {}, {}, {}, {
                    type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                } & {
                    default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                };
            }>> & Readonly<{}>, {
                loadingClasses: import("vue").ComputedRef<string>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
                type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                install: import("vue").FunctionPlugin<Record<string, never>>;
            } & {
                meta: Kotti.Meta<z.ZodObject<{
                    type: z.ZodDefault<z.ZodEnum<["circle", "rectangle", "rectangle-lg", "rectangle-md", "rectangle-sm", "square"]>>;
                }, "strip", z.ZodTypeAny, {
                    type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                }, {
                    type?: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square" | undefined;
                }>> & Record<string, unknown>;
            };
        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
            install: import("vue").FunctionPlugin<Record<string, never>>;
        } & {
            meta: Kotti.Meta<z.ZodObject<{
                size: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodEnum<["large" | "medium" | "small", ...("large" | "medium" | "small")[]]>, z.ZodNativeEnum<typeof Kotti.Field.Size>]>>>;
                isDisabled: z.ZodDefault<z.ZodBoolean>;
                isLoading: z.ZodDefault<z.ZodBoolean>;
                hideClear: z.ZodNever;
                hideValidation: z.ZodDefault<z.ZodBoolean>;
                isBorderless: z.ZodNever;
                inputId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                dataTest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                formKey: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodLiteral<"NONE">]>>>;
                helpDescription: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                helpText: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                leftIcon: z.ZodNever;
                placeholder: z.ZodNever;
                isOptional: z.ZodDefault<z.ZodBoolean>;
                label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                rightIcon: z.ZodNever;
                prefix: z.ZodNever;
                showVisibilityToggle: z.ZodDefault<z.ZodBoolean>;
                suffix: z.ZodNever;
                tabIndex: z.ZodNever;
                validator: z.ZodDefault<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodUnion<[z.ZodObject<{
                    type: z.ZodLiteral<"empty">;
                }, "strip", z.ZodTypeAny, {
                    type: "empty";
                }, {
                    type: "empty";
                }>, z.ZodObject<{
                    text: z.ZodNullable<z.ZodString>;
                    type: z.ZodLiteral<"error">;
                }, "strip", z.ZodTypeAny, {
                    type: "error";
                    text: string | null;
                }, {
                    type: "error";
                    text: string | null;
                }>, z.ZodObject<{
                    text: z.ZodNullable<z.ZodString>;
                    type: z.ZodLiteral<"success">;
                }, "strip", z.ZodTypeAny, {
                    type: "success";
                    text: string | null;
                }, {
                    type: "success";
                    text: string | null;
                }>, z.ZodObject<{
                    text: z.ZodNullable<z.ZodString>;
                    type: z.ZodLiteral<"warning">;
                }, "strip", z.ZodTypeAny, {
                    type: "warning";
                    text: string | null;
                }, {
                    type: "warning";
                    text: string | null;
                }>]>>>;
                modelValue: z.ZodNever;
            }, "strip", z.ZodTypeAny, {
                dataTest: string | null;
                label: string | null;
                size: "large" | "medium" | "small" | Kotti.Field.Size | null;
                isDisabled: boolean;
                isLoading: boolean;
                helpText: string | null;
                tabIndex: never;
                modelValue: never;
                placeholder: never;
                hideClear: never;
                hideValidation: boolean;
                showVisibilityToggle: boolean;
                isBorderless: never;
                inputId: string | null;
                formKey: string | null;
                helpDescription: string | null;
                leftIcon: never;
                isOptional: boolean;
                rightIcon: never;
                prefix: never;
                suffix: never;
                validator: (args_0: any, ...args: unknown[]) => {
                    type: "empty";
                } | {
                    type: "error";
                    text: string | null;
                } | {
                    type: "success";
                    text: string | null;
                } | {
                    type: "warning";
                    text: string | null;
                };
            }, {
                tabIndex: never;
                modelValue: never;
                placeholder: never;
                hideClear: never;
                isBorderless: never;
                leftIcon: never;
                rightIcon: never;
                prefix: never;
                suffix: never;
                size?: "large" | "medium" | "small" | Kotti.Field.Size | null | undefined;
                isDisabled?: boolean | undefined;
                isLoading?: boolean | undefined;
                hideValidation?: boolean | undefined;
                inputId?: string | null | undefined;
                dataTest?: string | null | undefined;
                formKey?: string | null | undefined;
                helpDescription?: string | null | undefined;
                helpText?: string | null | undefined;
                isOptional?: boolean | undefined;
                label?: string | null | undefined;
                showVisibilityToggle?: boolean | undefined;
                validator?: ((args_0: any, ...args: unknown[]) => {
                    type: "empty";
                } | {
                    type: "error";
                    text: string | null;
                } | {
                    type: "success";
                    text: string | null;
                } | {
                    type: "warning";
                    text: string | null;
                }) | undefined;
            }>> & Record<string, unknown>;
        };
        ToggleInner: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            component: {
                required: true;
                type: StringConstructor;
            };
            inputProps: {
                required: true;
                type: import("vue").PropType<Kotti.Field.Hook.Returns<KottiFieldToggle.ModelValue>["inputProps"]>;
            };
            isDisabled: {
                required: true;
                type: BooleanConstructor;
            };
            modelValue: {
                default: null;
                type: import("vue").PropType<boolean | null>;
            };
            type: {
                default: string;
                type: StringConstructor;
            };
        }>, {
            onInput: (event: Event) => void;
            svgComponent: import("vue").ComputedRef<{
                class: {
                    'kt-field-toggle-inner__svg': boolean;
                    'kt-field-toggle-inner__svg--is-box': boolean;
                    'kt-field-toggle-inner__svg--is-switch': boolean;
                };
                is: string | undefined;
            }>;
            toggleClasses: import("vue").ComputedRef<{
                'kt-field-toggle-inner--is-disabled': boolean;
                'kt-field-toggle-inner--is-indeterminate': boolean;
                'kt-field-toggle-inner--is-off': boolean;
                'kt-field-toggle-inner--is-on': boolean;
            }>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            component: {
                required: true;
                type: StringConstructor;
            };
            inputProps: {
                required: true;
                type: import("vue").PropType<Kotti.Field.Hook.Returns<KottiFieldToggle.ModelValue>["inputProps"]>;
            };
            isDisabled: {
                required: true;
                type: BooleanConstructor;
            };
            modelValue: {
                default: null;
                type: import("vue").PropType<boolean | null>;
            };
            type: {
                default: string;
                type: StringConstructor;
            };
        }>> & Readonly<{
            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
        }>, {
            type: string;
            modelValue: boolean | null;
        }, {}, {
            ToggleBox: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            ToggleSwitch: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import("vue").ExtractPropTypes<{
        dataTest: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        type: Omit<import("vue").Prop<"switch" | "checkbox" | Kotti.FieldToggle.Shared.Type>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<"switch" | "checkbox" | Kotti.FieldToggle.Shared.Type>;
        } & {
            default: () => "switch" | "checkbox" | Kotti.FieldToggle.Shared.Type;
        };
        label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        size: Omit<import("vue").Prop<"large" | "medium" | "small" | Kotti.Field.Size | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<"large" | "medium" | "small" | Kotti.Field.Size | null>;
        } & {
            default: () => "large" | "medium" | "small" | Kotti.Field.Size | null;
        };
        isDisabled: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        isLoading: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        tabIndex: Omit<import("vue").Prop<number>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<number>;
        } & {
            default: () => number;
        };
        placeholder: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        hideClear: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        hideValidation: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        showVisibilityToggle: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        isBorderless: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        formKey: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        leftIcon: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        isOptional: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        rightIcon: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        prefix: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        suffix: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        validator: Omit<import("vue").Prop<(args_0: any, ...args: unknown[]) => {
            type: "empty";
        } | {
            type: "error";
            text: string | null;
        } | {
            type: "success";
            text: string | null;
        } | {
            type: "warning";
            text: string | null;
        }>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<(args_0: any, ...args: unknown[]) => {
                type: "empty";
            } | {
                type: "error";
                text: string | null;
            } | {
                type: "success";
                text: string | null;
            } | {
                type: "warning";
                text: string | null;
            }>;
        } & {
            default: () => (args_0: any, ...args: unknown[]) => {
                type: "empty";
            } | {
                type: "error";
                text: string | null;
            } | {
                type: "success";
                text: string | null;
            } | {
                type: "warning";
                text: string | null;
            };
        };
        modelValue: Omit<import("vue").Prop<boolean | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean | null>;
        } & {
            default: () => boolean | null;
        };
    }>> & Readonly<{
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    }>, {
        fieldProps: import("vue").ComputedRef<{
            helpText: string | null;
            label: string | null;
            size: "large" | "medium" | "small" | Kotti.Field.Size | null;
            isDisabled: boolean;
            isLoading: boolean;
            hideClear: any;
            hideValidation: boolean;
            showVisibilityToggle: boolean;
            isBorderless: any;
            helpDescription: string | null;
            leftIcon: any;
            isOptional: boolean;
            rightIcon: any;
            prefix: any;
            suffix: any;
            currentValue: boolean | null;
            hasClear: boolean;
            inputProps: Readonly<{
                "data-test": string;
                disabled: boolean;
                id: string;
                tabindex: number;
            }>;
            isEmpty: boolean;
            setValue(newValue: boolean | null, options?: {
                forceUpdate: boolean;
            }): void;
            validation: Readonly<{
                type: "empty";
            } | {
                type: "error";
                text: string | null;
            } | {
                type: "success";
                text: string | null;
            } | {
                type: "warning";
                text: string | null;
            }>;
        }>;
        hasHelpText: import("vue").ComputedRef<boolean>;
        iconClasses: import("vue").ComputedRef<(element: string, modifications: string[]) => string[]>;
        inputProps: import("vue").ComputedRef<{
            forceUpdateKey: number;
            'data-test': string;
            disabled: boolean;
            id: string;
            tabindex: number;
        }>;
        labelSuffix: import("vue").ComputedRef<"*" | null>;
        labelSuffixClasses: import("vue").ComputedRef<{
            'kt-field__header__label__suffix': boolean;
            'kt-field__header__label__suffix--error': boolean;
        }>;
        onInput: (newValue: boolean | undefined) => void;
        showHelpTextAsInnerSuffix: import("vue").ComputedRef<boolean>;
    }, {}, {}, {}, {
        dataTest: string | null;
        type: "switch" | "checkbox" | Kotti.FieldToggle.Shared.Type;
        label: string | null;
        size: "large" | "medium" | "small" | Kotti.Field.Size | null;
        isDisabled: boolean;
        isLoading: boolean;
        helpText: string | null;
        tabIndex: number;
        modelValue: boolean | null;
        hideValidation: boolean;
        showVisibilityToggle: boolean;
        inputId: string | null;
        formKey: string | null;
        helpDescription: string | null;
        isOptional: boolean;
        validator: (args_0: any, ...args: unknown[]) => {
            type: "empty";
        } | {
            type: "error";
            text: string | null;
        } | {
            type: "success";
            text: string | null;
        } | {
            type: "warning";
            text: string | null;
        };
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
    dataTest: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<string | null>;
    } & {
        default: () => string | null;
    };
    type: Omit<import("vue").Prop<"switch" | "checkbox" | Kotti.FieldToggle.Shared.Type>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<"switch" | "checkbox" | Kotti.FieldToggle.Shared.Type>;
    } & {
        default: () => "switch" | "checkbox" | Kotti.FieldToggle.Shared.Type;
    };
    label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<string | null>;
    } & {
        default: () => string | null;
    };
    size: Omit<import("vue").Prop<"large" | "medium" | "small" | Kotti.Field.Size | null>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<"large" | "medium" | "small" | Kotti.Field.Size | null>;
    } & {
        default: () => "large" | "medium" | "small" | Kotti.Field.Size | null;
    };
    isDisabled: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<boolean>;
    } & {
        default: () => boolean;
    };
    isLoading: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<boolean>;
    } & {
        default: () => boolean;
    };
    helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<string | null>;
    } & {
        default: () => string | null;
    };
    tabIndex: Omit<import("vue").Prop<number>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<number>;
    } & {
        default: () => number;
    };
    placeholder: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
        required: true;
        type: import("vue").PropType<never>;
    } & Record<string, never>;
    hideClear: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
        required: true;
        type: import("vue").PropType<never>;
    } & Record<string, never>;
    hideValidation: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<boolean>;
    } & {
        default: () => boolean;
    };
    showVisibilityToggle: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<boolean>;
    } & {
        default: () => boolean;
    };
    isBorderless: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
        required: true;
        type: import("vue").PropType<never>;
    } & Record<string, never>;
    inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<string | null>;
    } & {
        default: () => string | null;
    };
    formKey: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<string | null>;
    } & {
        default: () => string | null;
    };
    helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<string | null>;
    } & {
        default: () => string | null;
    };
    leftIcon: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
        required: true;
        type: import("vue").PropType<never>;
    } & Record<string, never>;
    isOptional: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<boolean>;
    } & {
        default: () => boolean;
    };
    rightIcon: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
        required: true;
        type: import("vue").PropType<never>;
    } & Record<string, never>;
    prefix: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
        required: true;
        type: import("vue").PropType<never>;
    } & Record<string, never>;
    suffix: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
        required: true;
        type: import("vue").PropType<never>;
    } & Record<string, never>;
    validator: Omit<import("vue").Prop<(args_0: any, ...args: unknown[]) => {
        type: "empty";
    } | {
        type: "error";
        text: string | null;
    } | {
        type: "success";
        text: string | null;
    } | {
        type: "warning";
        text: string | null;
    }>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<(args_0: any, ...args: unknown[]) => {
            type: "empty";
        } | {
            type: "error";
            text: string | null;
        } | {
            type: "success";
            text: string | null;
        } | {
            type: "warning";
            text: string | null;
        }>;
    } & {
        default: () => (args_0: any, ...args: unknown[]) => {
            type: "empty";
        } | {
            type: "error";
            text: string | null;
        } | {
            type: "success";
            text: string | null;
        } | {
            type: "warning";
            text: string | null;
        };
    };
    modelValue: Omit<import("vue").Prop<boolean | null>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<boolean | null>;
    } & {
        default: () => boolean | null;
    };
}>> & Readonly<{
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
    fieldProps: import("vue").ComputedRef<{
        helpText: string | null;
        label: string | null;
        size: "large" | "medium" | "small" | Kotti.Field.Size | null;
        isDisabled: boolean;
        isLoading: boolean;
        hideClear: any;
        hideValidation: boolean;
        showVisibilityToggle: boolean;
        isBorderless: any;
        helpDescription: string | null;
        leftIcon: any;
        isOptional: boolean;
        rightIcon: any;
        prefix: any;
        suffix: any;
        currentValue: boolean | null;
        hasClear: boolean;
        inputProps: Readonly<{
            "data-test": string;
            disabled: boolean;
            id: string;
            tabindex: number;
        }>;
        isEmpty: boolean;
        setValue(newValue: boolean | null, options?: {
            forceUpdate: boolean;
        }): void;
        validation: Readonly<{
            type: "empty";
        } | {
            type: "error";
            text: string | null;
        } | {
            type: "success";
            text: string | null;
        } | {
            type: "warning";
            text: string | null;
        }>;
    }>;
    hasHelpText: import("vue").ComputedRef<boolean>;
    iconClasses: import("vue").ComputedRef<(element: string, modifications: string[]) => string[]>;
    inputProps: import("vue").ComputedRef<{
        forceUpdateKey: number;
        'data-test': string;
        disabled: boolean;
        id: string;
        tabindex: number;
    }>;
    labelSuffix: import("vue").ComputedRef<"*" | null>;
    labelSuffixClasses: import("vue").ComputedRef<{
        'kt-field__header__label__suffix': boolean;
        'kt-field__header__label__suffix--error': boolean;
    }>;
    onInput: (newValue: boolean | undefined) => void;
    showHelpTextAsInnerSuffix: import("vue").ComputedRef<boolean>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", {
    dataTest: string | null;
    type: "switch" | "checkbox" | Kotti.FieldToggle.Shared.Type;
    label: string | null;
    size: "large" | "medium" | "small" | Kotti.Field.Size | null;
    isDisabled: boolean;
    isLoading: boolean;
    helpText: string | null;
    tabIndex: number;
    modelValue: boolean | null;
    hideValidation: boolean;
    showVisibilityToggle: boolean;
    inputId: string | null;
    formKey: string | null;
    helpDescription: string | null;
    isOptional: boolean;
    validator: (args_0: any, ...args: unknown[]) => {
        type: "empty";
    } | {
        type: "error";
        text: string | null;
    } | {
        type: "success";
        text: string | null;
    } | {
        type: "warning";
        text: string | null;
    };
}, {}, string, {}, {
    FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        helpText: {
            default: null;
            type: import("vue").PropType<string | null>;
        };
        helpTextSlot: {
            default: undefined;
            type: import("vue").PropType<import("vue").Slot<undefined>>;
        };
    }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
        [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        helpText: {
            default: null;
            type: import("vue").PropType<string | null>;
        };
        helpTextSlot: {
            default: undefined;
            type: import("vue").PropType<import("vue").Slot<undefined>>;
        };
    }>> & Readonly<{}>, {
        helpText: string | null;
        helpTextSlot: import("vue").Slot<undefined>;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    KtField: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            debounceLabelClick: {
                default: boolean;
                type: BooleanConstructor;
            };
            field: {
                required: true;
                type: import("vue").PropType<Kotti.Field.Hook.Returns<unknown>>;
            };
            getEmptyValue: {
                default: null;
                type: import("vue").PropType<() => unknown>;
            };
            helpTextSlot: {
                default: undefined;
                type: import("vue").PropType<import("vue").Slot<undefined>>;
            };
            isRange: {
                default: boolean;
                type: BooleanConstructor;
            };
            useFieldset: {
                default: boolean;
                type: BooleanConstructor;
            };
        }>> & Readonly<{
            onClick?: ((...args: any[]) => any) | undefined;
            onMousedown?: ((...args: any[]) => any) | undefined;
            onVisibilityChange?: ((...args: any[]) => any) | undefined;
        }>, {
            affixClasses: import("vue").ComputedRef<(modifications: string[]) => string[]>;
            focusInput: () => void;
            handleClear: () => void;
            handleVisibilityChange: () => void;
            iconClasses: import("vue").ComputedRef<(element: string, modifications: string[]) => string[]>;
            inputId: import("vue").ComputedRef<string>;
            inputContainerRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
            inputContainerWrapperRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
            onClickLabel: (event: MouseEvent) => void;
            showLabel: import("vue").ComputedRef<true | import("vue").Slot<undefined> | undefined>;
            showValidation: import("vue").ComputedRef<boolean>;
            validationState: import("vue").ComputedRef<"error" | "empty">;
            validationText: import("vue").ComputedRef<string | null>;
            validationTextIcon: import("vue").ComputedRef<import("@3yourmind/yoco").Yoco.Icon | null>;
            valueVisibility: import("vue").Ref<boolean, boolean>;
            wrapperClasses: import("vue").ComputedRef<string[]>;
            Yoco: typeof import("@3yourmind/yoco").Yoco;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "mousedown" | "visibilityChange")[], import("vue").PublicProps, {
            helpTextSlot: import("vue").Slot<undefined>;
            debounceLabelClick: boolean;
            getEmptyValue: () => unknown;
            isRange: boolean;
            useFieldset: boolean;
        }, true, {}, {}, {
            FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                helpText: {
                    default: null;
                    type: import("vue").PropType<string | null>;
                };
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
            }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                [key: string]: any;
            }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                helpText: {
                    default: null;
                    type: import("vue").PropType<string | null>;
                };
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
            }>> & Readonly<{}>, {
                helpText: string | null;
                helpTextSlot: import("vue").Slot<undefined>;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            KtLabel: {
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                    label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<boolean>;
                    } & {
                        default: () => boolean;
                    };
                    validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                    } & {
                        default: () => "error" | "success" | "warning" | "empty";
                    };
                }>> & Readonly<{
                    onClick?: ((...args: any[]) => any) | undefined;
                }>, {
                    hasHelpText: import("vue").ComputedRef<boolean>;
                    labelSuffix: import("vue").ComputedRef<"*" | null>;
                    labelSuffixClasses: import("vue").ComputedRef<{
                        [x: string]: boolean;
                        'kt-label__header-label-suffix': boolean;
                    }>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], import("vue").PublicProps, {
                    label: string | null;
                    helpText: string | null;
                    inputId: string | null;
                    helpDescription: string | null;
                    helpTextSlot: import("vue").Slot<undefined>;
                    isRequired: boolean;
                    validationState: "error" | "success" | "warning" | "empty";
                }, true, {}, {}, {
                    FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        helpText: {
                            default: null;
                            type: import("vue").PropType<string | null>;
                        };
                        helpTextSlot: {
                            default: undefined;
                            type: import("vue").PropType<import("vue").Slot<undefined>>;
                        };
                    }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                        [key: string]: any;
                    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        helpText: {
                            default: null;
                            type: import("vue").PropType<string | null>;
                        };
                        helpTextSlot: {
                            default: undefined;
                            type: import("vue").PropType<import("vue").Slot<undefined>>;
                        };
                    }>> & Readonly<{}>, {
                        helpText: string | null;
                        helpTextSlot: import("vue").Slot<undefined>;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import("vue").ExtractPropTypes<{
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                    label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<boolean>;
                    } & {
                        default: () => boolean;
                    };
                    validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                    } & {
                        default: () => "error" | "success" | "warning" | "empty";
                    };
                }>> & Readonly<{
                    onClick?: ((...args: any[]) => any) | undefined;
                }>, {
                    hasHelpText: import("vue").ComputedRef<boolean>;
                    labelSuffix: import("vue").ComputedRef<"*" | null>;
                    labelSuffixClasses: import("vue").ComputedRef<{
                        [x: string]: boolean;
                        'kt-label__header-label-suffix': boolean;
                    }>;
                }, {}, {}, {}, {
                    label: string | null;
                    helpText: string | null;
                    inputId: string | null;
                    helpDescription: string | null;
                    helpTextSlot: import("vue").Slot<undefined>;
                    isRequired: boolean;
                    validationState: "error" | "success" | "warning" | "empty";
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
                label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<boolean>;
                } & {
                    default: () => boolean;
                };
                validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                } & {
                    default: () => "error" | "success" | "warning" | "empty";
                };
            }>> & Readonly<{
                onClick?: ((...args: any[]) => any) | undefined;
            }>, {
                hasHelpText: import("vue").ComputedRef<boolean>;
                labelSuffix: import("vue").ComputedRef<"*" | null>;
                labelSuffixClasses: import("vue").ComputedRef<{
                    [x: string]: boolean;
                    'kt-label__header-label-suffix': boolean;
                }>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", {
                label: string | null;
                helpText: string | null;
                inputId: string | null;
                helpDescription: string | null;
                helpTextSlot: import("vue").Slot<undefined>;
                isRequired: boolean;
                validationState: "error" | "success" | "warning" | "empty";
            }, {}, string, {}, {
                FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    helpText: {
                        default: null;
                        type: import("vue").PropType<string | null>;
                    };
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    helpText: {
                        default: null;
                        type: import("vue").PropType<string | null>;
                    };
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                }>> & Readonly<{}>, {
                    helpText: string | null;
                    helpTextSlot: import("vue").Slot<undefined>;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                install: import("vue").FunctionPlugin<Record<string, never>>;
            } & {
                meta: Kotti.Meta<z.ZodObject<{
                    label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    helpText: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    helpDescription: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    inputId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    isRequired: z.ZodDefault<z.ZodBoolean>;
                    validationState: z.ZodDefault<z.ZodEnum<["empty", "error", "success", "warning"]>>;
                }, "strip", z.ZodTypeAny, {
                    label: string | null;
                    helpText: string | null;
                    inputId: string | null;
                    helpDescription: string | null;
                    isRequired: boolean;
                    validationState: "error" | "success" | "warning" | "empty";
                }, {
                    label?: string | null | undefined;
                    helpText?: string | null | undefined;
                    helpDescription?: string | null | undefined;
                    inputId?: string | null | undefined;
                    isRequired?: boolean | undefined;
                    validationState?: "error" | "success" | "warning" | "empty" | undefined;
                }>> & Record<string, unknown>;
            };
            KtLoading: {
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                    type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                    } & {
                        default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                    };
                }>> & Readonly<{}>, {
                    loadingClasses: import("vue").ComputedRef<string>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
                    type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import("vue").ExtractPropTypes<{
                    type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                    } & {
                        default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                    };
                }>> & Readonly<{}>, {
                    loadingClasses: import("vue").ComputedRef<string>;
                }, {}, {}, {}, {
                    type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                } & {
                    default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                };
            }>> & Readonly<{}>, {
                loadingClasses: import("vue").ComputedRef<string>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
                type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                install: import("vue").FunctionPlugin<Record<string, never>>;
            } & {
                meta: Kotti.Meta<z.ZodObject<{
                    type: z.ZodDefault<z.ZodEnum<["circle", "rectangle", "rectangle-lg", "rectangle-md", "rectangle-sm", "square"]>>;
                }, "strip", z.ZodTypeAny, {
                    type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                }, {
                    type?: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square" | undefined;
                }>> & Record<string, unknown>;
            };
        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            debounceLabelClick: {
                default: boolean;
                type: BooleanConstructor;
            };
            field: {
                required: true;
                type: import("vue").PropType<Kotti.Field.Hook.Returns<unknown>>;
            };
            getEmptyValue: {
                default: null;
                type: import("vue").PropType<() => unknown>;
            };
            helpTextSlot: {
                default: undefined;
                type: import("vue").PropType<import("vue").Slot<undefined>>;
            };
            isRange: {
                default: boolean;
                type: BooleanConstructor;
            };
            useFieldset: {
                default: boolean;
                type: BooleanConstructor;
            };
        }>> & Readonly<{
            onClick?: ((...args: any[]) => any) | undefined;
            onMousedown?: ((...args: any[]) => any) | undefined;
            onVisibilityChange?: ((...args: any[]) => any) | undefined;
        }>, {
            affixClasses: import("vue").ComputedRef<(modifications: string[]) => string[]>;
            focusInput: () => void;
            handleClear: () => void;
            handleVisibilityChange: () => void;
            iconClasses: import("vue").ComputedRef<(element: string, modifications: string[]) => string[]>;
            inputId: import("vue").ComputedRef<string>;
            inputContainerRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
            inputContainerWrapperRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
            onClickLabel: (event: MouseEvent) => void;
            showLabel: import("vue").ComputedRef<true | import("vue").Slot<undefined> | undefined>;
            showValidation: import("vue").ComputedRef<boolean>;
            validationState: import("vue").ComputedRef<"error" | "empty">;
            validationText: import("vue").ComputedRef<string | null>;
            validationTextIcon: import("vue").ComputedRef<import("@3yourmind/yoco").Yoco.Icon | null>;
            valueVisibility: import("vue").Ref<boolean, boolean>;
            wrapperClasses: import("vue").ComputedRef<string[]>;
            Yoco: typeof import("@3yourmind/yoco").Yoco;
        }, {}, {}, {}, {
            helpTextSlot: import("vue").Slot<undefined>;
            debounceLabelClick: boolean;
            getEmptyValue: () => unknown;
            isRange: boolean;
            useFieldset: boolean;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
        debounceLabelClick: {
            default: boolean;
            type: BooleanConstructor;
        };
        field: {
            required: true;
            type: import("vue").PropType<Kotti.Field.Hook.Returns<unknown>>;
        };
        getEmptyValue: {
            default: null;
            type: import("vue").PropType<() => unknown>;
        };
        helpTextSlot: {
            default: undefined;
            type: import("vue").PropType<import("vue").Slot<undefined>>;
        };
        isRange: {
            default: boolean;
            type: BooleanConstructor;
        };
        useFieldset: {
            default: boolean;
            type: BooleanConstructor;
        };
    }>> & Readonly<{
        onClick?: ((...args: any[]) => any) | undefined;
        onMousedown?: ((...args: any[]) => any) | undefined;
        onVisibilityChange?: ((...args: any[]) => any) | undefined;
    }>, {
        affixClasses: import("vue").ComputedRef<(modifications: string[]) => string[]>;
        focusInput: () => void;
        handleClear: () => void;
        handleVisibilityChange: () => void;
        iconClasses: import("vue").ComputedRef<(element: string, modifications: string[]) => string[]>;
        inputId: import("vue").ComputedRef<string>;
        inputContainerRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
        inputContainerWrapperRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
        onClickLabel: (event: MouseEvent) => void;
        showLabel: import("vue").ComputedRef<true | import("vue").Slot<undefined> | undefined>;
        showValidation: import("vue").ComputedRef<boolean>;
        validationState: import("vue").ComputedRef<"error" | "empty">;
        validationText: import("vue").ComputedRef<string | null>;
        validationTextIcon: import("vue").ComputedRef<import("@3yourmind/yoco").Yoco.Icon | null>;
        valueVisibility: import("vue").Ref<boolean, boolean>;
        wrapperClasses: import("vue").ComputedRef<string[]>;
        Yoco: typeof import("@3yourmind/yoco").Yoco;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "mousedown" | "visibilityChange")[], "click" | "mousedown" | "visibilityChange", {
        helpTextSlot: import("vue").Slot<undefined>;
        debounceLabelClick: boolean;
        getEmptyValue: () => unknown;
        isRange: boolean;
        useFieldset: boolean;
    }, {}, string, {}, {
        FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            helpText: {
                default: null;
                type: import("vue").PropType<string | null>;
            };
            helpTextSlot: {
                default: undefined;
                type: import("vue").PropType<import("vue").Slot<undefined>>;
            };
        }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            helpText: {
                default: null;
                type: import("vue").PropType<string | null>;
            };
            helpTextSlot: {
                default: undefined;
                type: import("vue").PropType<import("vue").Slot<undefined>>;
            };
        }>> & Readonly<{}>, {
            helpText: string | null;
            helpTextSlot: import("vue").Slot<undefined>;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        KtLabel: {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
                label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<boolean>;
                } & {
                    default: () => boolean;
                };
                validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                } & {
                    default: () => "error" | "success" | "warning" | "empty";
                };
            }>> & Readonly<{
                onClick?: ((...args: any[]) => any) | undefined;
            }>, {
                hasHelpText: import("vue").ComputedRef<boolean>;
                labelSuffix: import("vue").ComputedRef<"*" | null>;
                labelSuffixClasses: import("vue").ComputedRef<{
                    [x: string]: boolean;
                    'kt-label__header-label-suffix': boolean;
                }>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], import("vue").PublicProps, {
                label: string | null;
                helpText: string | null;
                inputId: string | null;
                helpDescription: string | null;
                helpTextSlot: import("vue").Slot<undefined>;
                isRequired: boolean;
                validationState: "error" | "success" | "warning" | "empty";
            }, true, {}, {}, {
                FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    helpText: {
                        default: null;
                        type: import("vue").PropType<string | null>;
                    };
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    helpText: {
                        default: null;
                        type: import("vue").PropType<string | null>;
                    };
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                }>> & Readonly<{}>, {
                    helpText: string | null;
                    helpTextSlot: import("vue").Slot<undefined>;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("vue").ExtractPropTypes<{
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
                label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<boolean>;
                } & {
                    default: () => boolean;
                };
                validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                } & {
                    default: () => "error" | "success" | "warning" | "empty";
                };
            }>> & Readonly<{
                onClick?: ((...args: any[]) => any) | undefined;
            }>, {
                hasHelpText: import("vue").ComputedRef<boolean>;
                labelSuffix: import("vue").ComputedRef<"*" | null>;
                labelSuffixClasses: import("vue").ComputedRef<{
                    [x: string]: boolean;
                    'kt-label__header-label-suffix': boolean;
                }>;
            }, {}, {}, {}, {
                label: string | null;
                helpText: string | null;
                inputId: string | null;
                helpDescription: string | null;
                helpTextSlot: import("vue").Slot<undefined>;
                isRequired: boolean;
                validationState: "error" | "success" | "warning" | "empty";
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            helpTextSlot: {
                default: undefined;
                type: import("vue").PropType<import("vue").Slot<undefined>>;
            };
            label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                required: false;
                type: import("vue").PropType<string | null>;
            } & {
                default: () => string | null;
            };
            helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                required: false;
                type: import("vue").PropType<string | null>;
            } & {
                default: () => string | null;
            };
            helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                required: false;
                type: import("vue").PropType<string | null>;
            } & {
                default: () => string | null;
            };
            inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                required: false;
                type: import("vue").PropType<string | null>;
            } & {
                default: () => string | null;
            };
            isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                required: false;
                type: import("vue").PropType<boolean>;
            } & {
                default: () => boolean;
            };
            validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                required: false;
                type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
            } & {
                default: () => "error" | "success" | "warning" | "empty";
            };
        }>> & Readonly<{
            onClick?: ((...args: any[]) => any) | undefined;
        }>, {
            hasHelpText: import("vue").ComputedRef<boolean>;
            labelSuffix: import("vue").ComputedRef<"*" | null>;
            labelSuffixClasses: import("vue").ComputedRef<{
                [x: string]: boolean;
                'kt-label__header-label-suffix': boolean;
            }>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", {
            label: string | null;
            helpText: string | null;
            inputId: string | null;
            helpDescription: string | null;
            helpTextSlot: import("vue").Slot<undefined>;
            isRequired: boolean;
            validationState: "error" | "success" | "warning" | "empty";
        }, {}, string, {}, {
            FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                helpText: {
                    default: null;
                    type: import("vue").PropType<string | null>;
                };
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
            }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                [key: string]: any;
            }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                helpText: {
                    default: null;
                    type: import("vue").PropType<string | null>;
                };
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
            }>> & Readonly<{}>, {
                helpText: string | null;
                helpTextSlot: import("vue").Slot<undefined>;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
            install: import("vue").FunctionPlugin<Record<string, never>>;
        } & {
            meta: Kotti.Meta<z.ZodObject<{
                label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                helpText: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                helpDescription: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                inputId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                isRequired: z.ZodDefault<z.ZodBoolean>;
                validationState: z.ZodDefault<z.ZodEnum<["empty", "error", "success", "warning"]>>;
            }, "strip", z.ZodTypeAny, {
                label: string | null;
                helpText: string | null;
                inputId: string | null;
                helpDescription: string | null;
                isRequired: boolean;
                validationState: "error" | "success" | "warning" | "empty";
            }, {
                label?: string | null | undefined;
                helpText?: string | null | undefined;
                helpDescription?: string | null | undefined;
                inputId?: string | null | undefined;
                isRequired?: boolean | undefined;
                validationState?: "error" | "success" | "warning" | "empty" | undefined;
            }>> & Record<string, unknown>;
        };
        KtLoading: {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                } & {
                    default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                };
            }>> & Readonly<{}>, {
                loadingClasses: import("vue").ComputedRef<string>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
                type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
            }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("vue").ExtractPropTypes<{
                type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                } & {
                    default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                };
            }>> & Readonly<{}>, {
                loadingClasses: import("vue").ComputedRef<string>;
            }, {}, {}, {}, {
                type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                required: false;
                type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
            } & {
                default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
            };
        }>> & Readonly<{}>, {
            loadingClasses: import("vue").ComputedRef<string>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
            type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
            install: import("vue").FunctionPlugin<Record<string, never>>;
        } & {
            meta: Kotti.Meta<z.ZodObject<{
                type: z.ZodDefault<z.ZodEnum<["circle", "rectangle", "rectangle-lg", "rectangle-md", "rectangle-sm", "square"]>>;
            }, "strip", z.ZodTypeAny, {
                type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
            }, {
                type?: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square" | undefined;
            }>> & Record<string, unknown>;
        };
    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
        install: import("vue").FunctionPlugin<Record<string, never>>;
    } & {
        meta: Kotti.Meta<z.ZodObject<{
            size: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodEnum<["large" | "medium" | "small", ...("large" | "medium" | "small")[]]>, z.ZodNativeEnum<typeof Kotti.Field.Size>]>>>;
            isDisabled: z.ZodDefault<z.ZodBoolean>;
            isLoading: z.ZodDefault<z.ZodBoolean>;
            hideClear: z.ZodNever;
            hideValidation: z.ZodDefault<z.ZodBoolean>;
            isBorderless: z.ZodNever;
            inputId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            dataTest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            formKey: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodLiteral<"NONE">]>>>;
            helpDescription: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            helpText: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            leftIcon: z.ZodNever;
            placeholder: z.ZodNever;
            isOptional: z.ZodDefault<z.ZodBoolean>;
            label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            rightIcon: z.ZodNever;
            prefix: z.ZodNever;
            showVisibilityToggle: z.ZodDefault<z.ZodBoolean>;
            suffix: z.ZodNever;
            tabIndex: z.ZodNever;
            validator: z.ZodDefault<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodUnion<[z.ZodObject<{
                type: z.ZodLiteral<"empty">;
            }, "strip", z.ZodTypeAny, {
                type: "empty";
            }, {
                type: "empty";
            }>, z.ZodObject<{
                text: z.ZodNullable<z.ZodString>;
                type: z.ZodLiteral<"error">;
            }, "strip", z.ZodTypeAny, {
                type: "error";
                text: string | null;
            }, {
                type: "error";
                text: string | null;
            }>, z.ZodObject<{
                text: z.ZodNullable<z.ZodString>;
                type: z.ZodLiteral<"success">;
            }, "strip", z.ZodTypeAny, {
                type: "success";
                text: string | null;
            }, {
                type: "success";
                text: string | null;
            }>, z.ZodObject<{
                text: z.ZodNullable<z.ZodString>;
                type: z.ZodLiteral<"warning">;
            }, "strip", z.ZodTypeAny, {
                type: "warning";
                text: string | null;
            }, {
                type: "warning";
                text: string | null;
            }>]>>>;
            modelValue: z.ZodNever;
        }, "strip", z.ZodTypeAny, {
            dataTest: string | null;
            label: string | null;
            size: "large" | "medium" | "small" | Kotti.Field.Size | null;
            isDisabled: boolean;
            isLoading: boolean;
            helpText: string | null;
            tabIndex: never;
            modelValue: never;
            placeholder: never;
            hideClear: never;
            hideValidation: boolean;
            showVisibilityToggle: boolean;
            isBorderless: never;
            inputId: string | null;
            formKey: string | null;
            helpDescription: string | null;
            leftIcon: never;
            isOptional: boolean;
            rightIcon: never;
            prefix: never;
            suffix: never;
            validator: (args_0: any, ...args: unknown[]) => {
                type: "empty";
            } | {
                type: "error";
                text: string | null;
            } | {
                type: "success";
                text: string | null;
            } | {
                type: "warning";
                text: string | null;
            };
        }, {
            tabIndex: never;
            modelValue: never;
            placeholder: never;
            hideClear: never;
            isBorderless: never;
            leftIcon: never;
            rightIcon: never;
            prefix: never;
            suffix: never;
            size?: "large" | "medium" | "small" | Kotti.Field.Size | null | undefined;
            isDisabled?: boolean | undefined;
            isLoading?: boolean | undefined;
            hideValidation?: boolean | undefined;
            inputId?: string | null | undefined;
            dataTest?: string | null | undefined;
            formKey?: string | null | undefined;
            helpDescription?: string | null | undefined;
            helpText?: string | null | undefined;
            isOptional?: boolean | undefined;
            label?: string | null | undefined;
            showVisibilityToggle?: boolean | undefined;
            validator?: ((args_0: any, ...args: unknown[]) => {
                type: "empty";
            } | {
                type: "error";
                text: string | null;
            } | {
                type: "success";
                text: string | null;
            } | {
                type: "warning";
                text: string | null;
            }) | undefined;
        }>> & Record<string, unknown>;
    };
    ToggleInner: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        component: {
            required: true;
            type: StringConstructor;
        };
        inputProps: {
            required: true;
            type: import("vue").PropType<Kotti.Field.Hook.Returns<KottiFieldToggle.ModelValue>["inputProps"]>;
        };
        isDisabled: {
            required: true;
            type: BooleanConstructor;
        };
        modelValue: {
            default: null;
            type: import("vue").PropType<boolean | null>;
        };
        type: {
            default: string;
            type: StringConstructor;
        };
    }>, {
        onInput: (event: Event) => void;
        svgComponent: import("vue").ComputedRef<{
            class: {
                'kt-field-toggle-inner__svg': boolean;
                'kt-field-toggle-inner__svg--is-box': boolean;
                'kt-field-toggle-inner__svg--is-switch': boolean;
            };
            is: string | undefined;
        }>;
        toggleClasses: import("vue").ComputedRef<{
            'kt-field-toggle-inner--is-disabled': boolean;
            'kt-field-toggle-inner--is-indeterminate': boolean;
            'kt-field-toggle-inner--is-off': boolean;
            'kt-field-toggle-inner--is-on': boolean;
        }>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        component: {
            required: true;
            type: StringConstructor;
        };
        inputProps: {
            required: true;
            type: import("vue").PropType<Kotti.Field.Hook.Returns<KottiFieldToggle.ModelValue>["inputProps"]>;
        };
        isDisabled: {
            required: true;
            type: BooleanConstructor;
        };
        modelValue: {
            default: null;
            type: import("vue").PropType<boolean | null>;
        };
        type: {
            default: string;
            type: StringConstructor;
        };
    }>> & Readonly<{
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    }>, {
        type: string;
        modelValue: boolean | null;
    }, {}, {
        ToggleBox: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        ToggleSwitch: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
} & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
    install: import("vue").FunctionPlugin<Record<string, never>>;
} & {
    meta: Kotti.Meta<z.ZodObject<{
        dataTest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        type: z.ZodDefault<z.ZodUnion<[z.ZodEnum<["switch" | "checkbox", ...("switch" | "checkbox")[]]>, z.ZodNativeEnum<typeof Kotti.FieldToggle.Shared.Type>]>>;
        label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        size: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodEnum<["large" | "medium" | "small", ...("large" | "medium" | "small")[]]>, z.ZodNativeEnum<typeof Kotti.Field.Size>]>>>;
        isDisabled: z.ZodDefault<z.ZodBoolean>;
        isLoading: z.ZodDefault<z.ZodBoolean>;
        helpText: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        tabIndex: z.ZodDefault<z.ZodNumber>;
        placeholder: z.ZodNever;
        hideClear: z.ZodNever;
        hideValidation: z.ZodDefault<z.ZodBoolean>;
        showVisibilityToggle: z.ZodDefault<z.ZodBoolean>;
        isBorderless: z.ZodNever;
        inputId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        formKey: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodLiteral<"NONE">]>>>;
        helpDescription: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        leftIcon: z.ZodNever;
        isOptional: z.ZodDefault<z.ZodBoolean>;
        rightIcon: z.ZodNever;
        prefix: z.ZodNever;
        suffix: z.ZodNever;
        validator: z.ZodDefault<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodUnion<[z.ZodObject<{
            type: z.ZodLiteral<"empty">;
        }, "strip", z.ZodTypeAny, {
            type: "empty";
        }, {
            type: "empty";
        }>, z.ZodObject<{
            text: z.ZodNullable<z.ZodString>;
            type: z.ZodLiteral<"error">;
        }, "strip", z.ZodTypeAny, {
            type: "error";
            text: string | null;
        }, {
            type: "error";
            text: string | null;
        }>, z.ZodObject<{
            text: z.ZodNullable<z.ZodString>;
            type: z.ZodLiteral<"success">;
        }, "strip", z.ZodTypeAny, {
            type: "success";
            text: string | null;
        }, {
            type: "success";
            text: string | null;
        }>, z.ZodObject<{
            text: z.ZodNullable<z.ZodString>;
            type: z.ZodLiteral<"warning">;
        }, "strip", z.ZodTypeAny, {
            type: "warning";
            text: string | null;
        }, {
            type: "warning";
            text: string | null;
        }>]>>>;
        modelValue: z.ZodDefault<z.ZodNullable<z.ZodBoolean>>;
    }, "strip", z.ZodTypeAny, {
        dataTest: string | null;
        type: "switch" | "checkbox" | Kotti.FieldToggle.Shared.Type;
        label: string | null;
        size: "large" | "medium" | "small" | Kotti.Field.Size | null;
        isDisabled: boolean;
        isLoading: boolean;
        helpText: string | null;
        tabIndex: number;
        modelValue: boolean | null;
        placeholder: never;
        hideClear: never;
        hideValidation: boolean;
        showVisibilityToggle: boolean;
        isBorderless: never;
        inputId: string | null;
        formKey: string | null;
        helpDescription: string | null;
        leftIcon: never;
        isOptional: boolean;
        rightIcon: never;
        prefix: never;
        suffix: never;
        validator: (args_0: any, ...args: unknown[]) => {
            type: "empty";
        } | {
            type: "error";
            text: string | null;
        } | {
            type: "success";
            text: string | null;
        } | {
            type: "warning";
            text: string | null;
        };
    }, {
        placeholder: never;
        hideClear: never;
        isBorderless: never;
        leftIcon: never;
        rightIcon: never;
        prefix: never;
        suffix: never;
        dataTest?: string | null | undefined;
        type?: "switch" | "checkbox" | Kotti.FieldToggle.Shared.Type | undefined;
        label?: string | null | undefined;
        size?: "large" | "medium" | "small" | Kotti.Field.Size | null | undefined;
        isDisabled?: boolean | undefined;
        isLoading?: boolean | undefined;
        helpText?: string | null | undefined;
        tabIndex?: number | undefined;
        hideValidation?: boolean | undefined;
        showVisibilityToggle?: boolean | undefined;
        inputId?: string | null | undefined;
        formKey?: string | null | undefined;
        helpDescription?: string | null | undefined;
        isOptional?: boolean | undefined;
        validator?: ((args_0: any, ...args: unknown[]) => {
            type: "empty";
        } | {
            type: "error";
            text: string | null;
        } | {
            type: "success";
            text: string | null;
        } | {
            type: "warning";
            text: string | null;
        }) | undefined;
        modelValue?: boolean | null | undefined;
    }>> & {
        supports: Kotti.Field.Supports;
    };
};
export declare const KtFieldToggleGroup: {
    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
        dataTest: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        type: Omit<import("vue").Prop<"switch" | "checkbox" | Kotti.FieldToggle.Shared.Type>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<"switch" | "checkbox" | Kotti.FieldToggle.Shared.Type>;
        } & {
            default: () => "switch" | "checkbox" | Kotti.FieldToggle.Shared.Type;
        };
        label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        size: Omit<import("vue").Prop<"large" | "medium" | "small" | Kotti.Field.Size | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<"large" | "medium" | "small" | Kotti.Field.Size | null>;
        } & {
            default: () => "large" | "medium" | "small" | Kotti.Field.Size | null;
        };
        isDisabled: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        isLoading: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        tabIndex: Omit<import("vue").Prop<number>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<number>;
        } & {
            default: () => number;
        };
        placeholder: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        hideClear: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        hideValidation: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        showVisibilityToggle: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        isBorderless: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        formKey: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        leftIcon: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        isOptional: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        rightIcon: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        prefix: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        suffix: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        validator: Omit<import("vue").Prop<(args_0: any, ...args: unknown[]) => {
            type: "empty";
        } | {
            type: "error";
            text: string | null;
        } | {
            type: "success";
            text: string | null;
        } | {
            type: "warning";
            text: string | null;
        }>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<(args_0: any, ...args: unknown[]) => {
                type: "empty";
            } | {
                type: "error";
                text: string | null;
            } | {
                type: "success";
                text: string | null;
            } | {
                type: "warning";
                text: string | null;
            }>;
        } & {
            default: () => (args_0: any, ...args: unknown[]) => {
                type: "empty";
            } | {
                type: "error";
                text: string | null;
            } | {
                type: "success";
                text: string | null;
            } | {
                type: "warning";
                text: string | null;
            };
        };
        isInline: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        modelValue: Omit<import("vue").Prop<Record<string, boolean | null> | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<Record<string, boolean | null> | null>;
        } & {
            default: () => Record<string, boolean | null> | null;
        };
        options: Omit<import("vue").Prop<{
            label: string;
            key: string;
            dataTest?: string | undefined;
            isDisabled?: boolean | undefined;
            tooltip?: string | undefined;
        }[]>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<{
                label: string;
                key: string;
                dataTest?: string | undefined;
                isDisabled?: boolean | undefined;
                tooltip?: string | undefined;
            }[]>;
        } & Record<string, never>;
    }>> & Readonly<{
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    }>, {
        field: Kotti.Field.Hook.Returns<Record<string, boolean | null> | null>;
        getOptionDataTest: (option: KottiFieldToggleGroup.Entry) => string | undefined;
        inputProps: import("vue").ComputedRef<(index: number) => {
            forceUpdateKey: number;
            id: string;
            disabled: boolean;
            'data-test': string;
            tabindex: number;
        }>;
        onUpdateModelValue: (key: KottiFieldToggleGroup.Entry["key"], newValue: boolean | undefined) => void;
        optionsWithChecked: import("vue").ComputedRef<{
            value: boolean | null | undefined;
            label: string;
            key: string;
            dataTest?: string | undefined;
            isDisabled?: boolean | undefined;
            tooltip?: string | undefined;
        }[]>;
        wrapperClasses: import("vue").ComputedRef<{
            'kt-field-toggle-group': boolean;
            'kt-field-toggle-group--inline': boolean;
        }>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], import("vue").PublicProps, {
        dataTest: string | null;
        type: "switch" | "checkbox" | Kotti.FieldToggle.Shared.Type;
        label: string | null;
        size: "large" | "medium" | "small" | Kotti.Field.Size | null;
        isDisabled: boolean;
        isLoading: boolean;
        helpText: string | null;
        tabIndex: number;
        modelValue: Record<string, boolean | null> | null;
        hideValidation: boolean;
        showVisibilityToggle: boolean;
        inputId: string | null;
        formKey: string | null;
        helpDescription: string | null;
        isOptional: boolean;
        validator: (args_0: any, ...args: unknown[]) => {
            type: "empty";
        } | {
            type: "error";
            text: string | null;
        } | {
            type: "success";
            text: string | null;
        } | {
            type: "warning";
            text: string | null;
        };
        isInline: boolean;
    }, true, {}, {}, {
        FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            helpText: {
                default: null;
                type: import("vue").PropType<string | null>;
            };
            helpTextSlot: {
                default: undefined;
                type: import("vue").PropType<import("vue").Slot<undefined>>;
            };
        }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            helpText: {
                default: null;
                type: import("vue").PropType<string | null>;
            };
            helpTextSlot: {
                default: undefined;
                type: import("vue").PropType<import("vue").Slot<undefined>>;
            };
        }>> & Readonly<{}>, {
            helpText: string | null;
            helpTextSlot: import("vue").Slot<undefined>;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        KtField: {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                debounceLabelClick: {
                    default: boolean;
                    type: BooleanConstructor;
                };
                field: {
                    required: true;
                    type: import("vue").PropType<Kotti.Field.Hook.Returns<unknown>>;
                };
                getEmptyValue: {
                    default: null;
                    type: import("vue").PropType<() => unknown>;
                };
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
                isRange: {
                    default: boolean;
                    type: BooleanConstructor;
                };
                useFieldset: {
                    default: boolean;
                    type: BooleanConstructor;
                };
            }>> & Readonly<{
                onClick?: ((...args: any[]) => any) | undefined;
                onMousedown?: ((...args: any[]) => any) | undefined;
                onVisibilityChange?: ((...args: any[]) => any) | undefined;
            }>, {
                affixClasses: import("vue").ComputedRef<(modifications: string[]) => string[]>;
                focusInput: () => void;
                handleClear: () => void;
                handleVisibilityChange: () => void;
                iconClasses: import("vue").ComputedRef<(element: string, modifications: string[]) => string[]>;
                inputId: import("vue").ComputedRef<string>;
                inputContainerRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
                inputContainerWrapperRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
                onClickLabel: (event: MouseEvent) => void;
                showLabel: import("vue").ComputedRef<true | import("vue").Slot<undefined> | undefined>;
                showValidation: import("vue").ComputedRef<boolean>;
                validationState: import("vue").ComputedRef<"error" | "empty">;
                validationText: import("vue").ComputedRef<string | null>;
                validationTextIcon: import("vue").ComputedRef<import("@3yourmind/yoco").Yoco.Icon | null>;
                valueVisibility: import("vue").Ref<boolean, boolean>;
                wrapperClasses: import("vue").ComputedRef<string[]>;
                Yoco: typeof import("@3yourmind/yoco").Yoco;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "mousedown" | "visibilityChange")[], import("vue").PublicProps, {
                helpTextSlot: import("vue").Slot<undefined>;
                debounceLabelClick: boolean;
                getEmptyValue: () => unknown;
                isRange: boolean;
                useFieldset: boolean;
            }, true, {}, {}, {
                FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    helpText: {
                        default: null;
                        type: import("vue").PropType<string | null>;
                    };
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    helpText: {
                        default: null;
                        type: import("vue").PropType<string | null>;
                    };
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                }>> & Readonly<{}>, {
                    helpText: string | null;
                    helpTextSlot: import("vue").Slot<undefined>;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                KtLabel: {
                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                        helpTextSlot: {
                            default: undefined;
                            type: import("vue").PropType<import("vue").Slot<undefined>>;
                        };
                        label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<string | null>;
                        } & {
                            default: () => string | null;
                        };
                        helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<string | null>;
                        } & {
                            default: () => string | null;
                        };
                        helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<string | null>;
                        } & {
                            default: () => string | null;
                        };
                        inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<string | null>;
                        } & {
                            default: () => string | null;
                        };
                        isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<boolean>;
                        } & {
                            default: () => boolean;
                        };
                        validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                        } & {
                            default: () => "error" | "success" | "warning" | "empty";
                        };
                    }>> & Readonly<{
                        onClick?: ((...args: any[]) => any) | undefined;
                    }>, {
                        hasHelpText: import("vue").ComputedRef<boolean>;
                        labelSuffix: import("vue").ComputedRef<"*" | null>;
                        labelSuffixClasses: import("vue").ComputedRef<{
                            [x: string]: boolean;
                            'kt-label__header-label-suffix': boolean;
                        }>;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], import("vue").PublicProps, {
                        label: string | null;
                        helpText: string | null;
                        inputId: string | null;
                        helpDescription: string | null;
                        helpTextSlot: import("vue").Slot<undefined>;
                        isRequired: boolean;
                        validationState: "error" | "success" | "warning" | "empty";
                    }, true, {}, {}, {
                        FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                            helpText: {
                                default: null;
                                type: import("vue").PropType<string | null>;
                            };
                            helpTextSlot: {
                                default: undefined;
                                type: import("vue").PropType<import("vue").Slot<undefined>>;
                            };
                        }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                            helpText: {
                                default: null;
                                type: import("vue").PropType<string | null>;
                            };
                            helpTextSlot: {
                                default: undefined;
                                type: import("vue").PropType<import("vue").Slot<undefined>>;
                            };
                        }>> & Readonly<{}>, {
                            helpText: string | null;
                            helpTextSlot: import("vue").Slot<undefined>;
                        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import("vue").ExtractPropTypes<{
                        helpTextSlot: {
                            default: undefined;
                            type: import("vue").PropType<import("vue").Slot<undefined>>;
                        };
                        label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<string | null>;
                        } & {
                            default: () => string | null;
                        };
                        helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<string | null>;
                        } & {
                            default: () => string | null;
                        };
                        helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<string | null>;
                        } & {
                            default: () => string | null;
                        };
                        inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<string | null>;
                        } & {
                            default: () => string | null;
                        };
                        isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<boolean>;
                        } & {
                            default: () => boolean;
                        };
                        validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                        } & {
                            default: () => "error" | "success" | "warning" | "empty";
                        };
                    }>> & Readonly<{
                        onClick?: ((...args: any[]) => any) | undefined;
                    }>, {
                        hasHelpText: import("vue").ComputedRef<boolean>;
                        labelSuffix: import("vue").ComputedRef<"*" | null>;
                        labelSuffixClasses: import("vue").ComputedRef<{
                            [x: string]: boolean;
                            'kt-label__header-label-suffix': boolean;
                        }>;
                    }, {}, {}, {}, {
                        label: string | null;
                        helpText: string | null;
                        inputId: string | null;
                        helpDescription: string | null;
                        helpTextSlot: import("vue").Slot<undefined>;
                        isRequired: boolean;
                        validationState: "error" | "success" | "warning" | "empty";
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                    label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<boolean>;
                    } & {
                        default: () => boolean;
                    };
                    validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                    } & {
                        default: () => "error" | "success" | "warning" | "empty";
                    };
                }>> & Readonly<{
                    onClick?: ((...args: any[]) => any) | undefined;
                }>, {
                    hasHelpText: import("vue").ComputedRef<boolean>;
                    labelSuffix: import("vue").ComputedRef<"*" | null>;
                    labelSuffixClasses: import("vue").ComputedRef<{
                        [x: string]: boolean;
                        'kt-label__header-label-suffix': boolean;
                    }>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", {
                    label: string | null;
                    helpText: string | null;
                    inputId: string | null;
                    helpDescription: string | null;
                    helpTextSlot: import("vue").Slot<undefined>;
                    isRequired: boolean;
                    validationState: "error" | "success" | "warning" | "empty";
                }, {}, string, {}, {
                    FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        helpText: {
                            default: null;
                            type: import("vue").PropType<string | null>;
                        };
                        helpTextSlot: {
                            default: undefined;
                            type: import("vue").PropType<import("vue").Slot<undefined>>;
                        };
                    }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                        [key: string]: any;
                    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        helpText: {
                            default: null;
                            type: import("vue").PropType<string | null>;
                        };
                        helpTextSlot: {
                            default: undefined;
                            type: import("vue").PropType<import("vue").Slot<undefined>>;
                        };
                    }>> & Readonly<{}>, {
                        helpText: string | null;
                        helpTextSlot: import("vue").Slot<undefined>;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                    install: import("vue").FunctionPlugin<Record<string, never>>;
                } & {
                    meta: Kotti.Meta<z.ZodObject<{
                        label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                        helpText: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                        helpDescription: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                        inputId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                        isRequired: z.ZodDefault<z.ZodBoolean>;
                        validationState: z.ZodDefault<z.ZodEnum<["empty", "error", "success", "warning"]>>;
                    }, "strip", z.ZodTypeAny, {
                        label: string | null;
                        helpText: string | null;
                        inputId: string | null;
                        helpDescription: string | null;
                        isRequired: boolean;
                        validationState: "error" | "success" | "warning" | "empty";
                    }, {
                        label?: string | null | undefined;
                        helpText?: string | null | undefined;
                        helpDescription?: string | null | undefined;
                        inputId?: string | null | undefined;
                        isRequired?: boolean | undefined;
                        validationState?: "error" | "success" | "warning" | "empty" | undefined;
                    }>> & Record<string, unknown>;
                };
                KtLoading: {
                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                        type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                        } & {
                            default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                        };
                    }>> & Readonly<{}>, {
                        loadingClasses: import("vue").ComputedRef<string>;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
                        type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import("vue").ExtractPropTypes<{
                        type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                            required: false;
                            type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                        } & {
                            default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                        };
                    }>> & Readonly<{}>, {
                        loadingClasses: import("vue").ComputedRef<string>;
                    }, {}, {}, {}, {
                        type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                    type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                    } & {
                        default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                    };
                }>> & Readonly<{}>, {
                    loadingClasses: import("vue").ComputedRef<string>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
                    type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                    install: import("vue").FunctionPlugin<Record<string, never>>;
                } & {
                    meta: Kotti.Meta<z.ZodObject<{
                        type: z.ZodDefault<z.ZodEnum<["circle", "rectangle", "rectangle-lg", "rectangle-md", "rectangle-sm", "square"]>>;
                    }, "strip", z.ZodTypeAny, {
                        type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                    }, {
                        type?: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square" | undefined;
                    }>> & Record<string, unknown>;
                };
            } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("vue").ExtractPropTypes<{
                debounceLabelClick: {
                    default: boolean;
                    type: BooleanConstructor;
                };
                field: {
                    required: true;
                    type: import("vue").PropType<Kotti.Field.Hook.Returns<unknown>>;
                };
                getEmptyValue: {
                    default: null;
                    type: import("vue").PropType<() => unknown>;
                };
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
                isRange: {
                    default: boolean;
                    type: BooleanConstructor;
                };
                useFieldset: {
                    default: boolean;
                    type: BooleanConstructor;
                };
            }>> & Readonly<{
                onClick?: ((...args: any[]) => any) | undefined;
                onMousedown?: ((...args: any[]) => any) | undefined;
                onVisibilityChange?: ((...args: any[]) => any) | undefined;
            }>, {
                affixClasses: import("vue").ComputedRef<(modifications: string[]) => string[]>;
                focusInput: () => void;
                handleClear: () => void;
                handleVisibilityChange: () => void;
                iconClasses: import("vue").ComputedRef<(element: string, modifications: string[]) => string[]>;
                inputId: import("vue").ComputedRef<string>;
                inputContainerRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
                inputContainerWrapperRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
                onClickLabel: (event: MouseEvent) => void;
                showLabel: import("vue").ComputedRef<true | import("vue").Slot<undefined> | undefined>;
                showValidation: import("vue").ComputedRef<boolean>;
                validationState: import("vue").ComputedRef<"error" | "empty">;
                validationText: import("vue").ComputedRef<string | null>;
                validationTextIcon: import("vue").ComputedRef<import("@3yourmind/yoco").Yoco.Icon | null>;
                valueVisibility: import("vue").Ref<boolean, boolean>;
                wrapperClasses: import("vue").ComputedRef<string[]>;
                Yoco: typeof import("@3yourmind/yoco").Yoco;
            }, {}, {}, {}, {
                helpTextSlot: import("vue").Slot<undefined>;
                debounceLabelClick: boolean;
                getEmptyValue: () => unknown;
                isRange: boolean;
                useFieldset: boolean;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            debounceLabelClick: {
                default: boolean;
                type: BooleanConstructor;
            };
            field: {
                required: true;
                type: import("vue").PropType<Kotti.Field.Hook.Returns<unknown>>;
            };
            getEmptyValue: {
                default: null;
                type: import("vue").PropType<() => unknown>;
            };
            helpTextSlot: {
                default: undefined;
                type: import("vue").PropType<import("vue").Slot<undefined>>;
            };
            isRange: {
                default: boolean;
                type: BooleanConstructor;
            };
            useFieldset: {
                default: boolean;
                type: BooleanConstructor;
            };
        }>> & Readonly<{
            onClick?: ((...args: any[]) => any) | undefined;
            onMousedown?: ((...args: any[]) => any) | undefined;
            onVisibilityChange?: ((...args: any[]) => any) | undefined;
        }>, {
            affixClasses: import("vue").ComputedRef<(modifications: string[]) => string[]>;
            focusInput: () => void;
            handleClear: () => void;
            handleVisibilityChange: () => void;
            iconClasses: import("vue").ComputedRef<(element: string, modifications: string[]) => string[]>;
            inputId: import("vue").ComputedRef<string>;
            inputContainerRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
            inputContainerWrapperRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
            onClickLabel: (event: MouseEvent) => void;
            showLabel: import("vue").ComputedRef<true | import("vue").Slot<undefined> | undefined>;
            showValidation: import("vue").ComputedRef<boolean>;
            validationState: import("vue").ComputedRef<"error" | "empty">;
            validationText: import("vue").ComputedRef<string | null>;
            validationTextIcon: import("vue").ComputedRef<import("@3yourmind/yoco").Yoco.Icon | null>;
            valueVisibility: import("vue").Ref<boolean, boolean>;
            wrapperClasses: import("vue").ComputedRef<string[]>;
            Yoco: typeof import("@3yourmind/yoco").Yoco;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "mousedown" | "visibilityChange")[], "click" | "mousedown" | "visibilityChange", {
            helpTextSlot: import("vue").Slot<undefined>;
            debounceLabelClick: boolean;
            getEmptyValue: () => unknown;
            isRange: boolean;
            useFieldset: boolean;
        }, {}, string, {}, {
            FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                helpText: {
                    default: null;
                    type: import("vue").PropType<string | null>;
                };
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
            }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                [key: string]: any;
            }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                helpText: {
                    default: null;
                    type: import("vue").PropType<string | null>;
                };
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
            }>> & Readonly<{}>, {
                helpText: string | null;
                helpTextSlot: import("vue").Slot<undefined>;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            KtLabel: {
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                    label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<boolean>;
                    } & {
                        default: () => boolean;
                    };
                    validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                    } & {
                        default: () => "error" | "success" | "warning" | "empty";
                    };
                }>> & Readonly<{
                    onClick?: ((...args: any[]) => any) | undefined;
                }>, {
                    hasHelpText: import("vue").ComputedRef<boolean>;
                    labelSuffix: import("vue").ComputedRef<"*" | null>;
                    labelSuffixClasses: import("vue").ComputedRef<{
                        [x: string]: boolean;
                        'kt-label__header-label-suffix': boolean;
                    }>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], import("vue").PublicProps, {
                    label: string | null;
                    helpText: string | null;
                    inputId: string | null;
                    helpDescription: string | null;
                    helpTextSlot: import("vue").Slot<undefined>;
                    isRequired: boolean;
                    validationState: "error" | "success" | "warning" | "empty";
                }, true, {}, {}, {
                    FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        helpText: {
                            default: null;
                            type: import("vue").PropType<string | null>;
                        };
                        helpTextSlot: {
                            default: undefined;
                            type: import("vue").PropType<import("vue").Slot<undefined>>;
                        };
                    }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                        [key: string]: any;
                    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        helpText: {
                            default: null;
                            type: import("vue").PropType<string | null>;
                        };
                        helpTextSlot: {
                            default: undefined;
                            type: import("vue").PropType<import("vue").Slot<undefined>>;
                        };
                    }>> & Readonly<{}>, {
                        helpText: string | null;
                        helpTextSlot: import("vue").Slot<undefined>;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import("vue").ExtractPropTypes<{
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                    label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<boolean>;
                    } & {
                        default: () => boolean;
                    };
                    validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                    } & {
                        default: () => "error" | "success" | "warning" | "empty";
                    };
                }>> & Readonly<{
                    onClick?: ((...args: any[]) => any) | undefined;
                }>, {
                    hasHelpText: import("vue").ComputedRef<boolean>;
                    labelSuffix: import("vue").ComputedRef<"*" | null>;
                    labelSuffixClasses: import("vue").ComputedRef<{
                        [x: string]: boolean;
                        'kt-label__header-label-suffix': boolean;
                    }>;
                }, {}, {}, {}, {
                    label: string | null;
                    helpText: string | null;
                    inputId: string | null;
                    helpDescription: string | null;
                    helpTextSlot: import("vue").Slot<undefined>;
                    isRequired: boolean;
                    validationState: "error" | "success" | "warning" | "empty";
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
                label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<boolean>;
                } & {
                    default: () => boolean;
                };
                validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                } & {
                    default: () => "error" | "success" | "warning" | "empty";
                };
            }>> & Readonly<{
                onClick?: ((...args: any[]) => any) | undefined;
            }>, {
                hasHelpText: import("vue").ComputedRef<boolean>;
                labelSuffix: import("vue").ComputedRef<"*" | null>;
                labelSuffixClasses: import("vue").ComputedRef<{
                    [x: string]: boolean;
                    'kt-label__header-label-suffix': boolean;
                }>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", {
                label: string | null;
                helpText: string | null;
                inputId: string | null;
                helpDescription: string | null;
                helpTextSlot: import("vue").Slot<undefined>;
                isRequired: boolean;
                validationState: "error" | "success" | "warning" | "empty";
            }, {}, string, {}, {
                FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    helpText: {
                        default: null;
                        type: import("vue").PropType<string | null>;
                    };
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    helpText: {
                        default: null;
                        type: import("vue").PropType<string | null>;
                    };
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                }>> & Readonly<{}>, {
                    helpText: string | null;
                    helpTextSlot: import("vue").Slot<undefined>;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                install: import("vue").FunctionPlugin<Record<string, never>>;
            } & {
                meta: Kotti.Meta<z.ZodObject<{
                    label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    helpText: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    helpDescription: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    inputId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    isRequired: z.ZodDefault<z.ZodBoolean>;
                    validationState: z.ZodDefault<z.ZodEnum<["empty", "error", "success", "warning"]>>;
                }, "strip", z.ZodTypeAny, {
                    label: string | null;
                    helpText: string | null;
                    inputId: string | null;
                    helpDescription: string | null;
                    isRequired: boolean;
                    validationState: "error" | "success" | "warning" | "empty";
                }, {
                    label?: string | null | undefined;
                    helpText?: string | null | undefined;
                    helpDescription?: string | null | undefined;
                    inputId?: string | null | undefined;
                    isRequired?: boolean | undefined;
                    validationState?: "error" | "success" | "warning" | "empty" | undefined;
                }>> & Record<string, unknown>;
            };
            KtLoading: {
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                    type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                    } & {
                        default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                    };
                }>> & Readonly<{}>, {
                    loadingClasses: import("vue").ComputedRef<string>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
                    type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import("vue").ExtractPropTypes<{
                    type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                    } & {
                        default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                    };
                }>> & Readonly<{}>, {
                    loadingClasses: import("vue").ComputedRef<string>;
                }, {}, {}, {}, {
                    type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                } & {
                    default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                };
            }>> & Readonly<{}>, {
                loadingClasses: import("vue").ComputedRef<string>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
                type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                install: import("vue").FunctionPlugin<Record<string, never>>;
            } & {
                meta: Kotti.Meta<z.ZodObject<{
                    type: z.ZodDefault<z.ZodEnum<["circle", "rectangle", "rectangle-lg", "rectangle-md", "rectangle-sm", "square"]>>;
                }, "strip", z.ZodTypeAny, {
                    type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                }, {
                    type?: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square" | undefined;
                }>> & Record<string, unknown>;
            };
        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
            install: import("vue").FunctionPlugin<Record<string, never>>;
        } & {
            meta: Kotti.Meta<z.ZodObject<{
                size: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodEnum<["large" | "medium" | "small", ...("large" | "medium" | "small")[]]>, z.ZodNativeEnum<typeof Kotti.Field.Size>]>>>;
                isDisabled: z.ZodDefault<z.ZodBoolean>;
                isLoading: z.ZodDefault<z.ZodBoolean>;
                hideClear: z.ZodNever;
                hideValidation: z.ZodDefault<z.ZodBoolean>;
                isBorderless: z.ZodNever;
                inputId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                dataTest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                formKey: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodLiteral<"NONE">]>>>;
                helpDescription: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                helpText: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                leftIcon: z.ZodNever;
                placeholder: z.ZodNever;
                isOptional: z.ZodDefault<z.ZodBoolean>;
                label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                rightIcon: z.ZodNever;
                prefix: z.ZodNever;
                showVisibilityToggle: z.ZodDefault<z.ZodBoolean>;
                suffix: z.ZodNever;
                tabIndex: z.ZodNever;
                validator: z.ZodDefault<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodUnion<[z.ZodObject<{
                    type: z.ZodLiteral<"empty">;
                }, "strip", z.ZodTypeAny, {
                    type: "empty";
                }, {
                    type: "empty";
                }>, z.ZodObject<{
                    text: z.ZodNullable<z.ZodString>;
                    type: z.ZodLiteral<"error">;
                }, "strip", z.ZodTypeAny, {
                    type: "error";
                    text: string | null;
                }, {
                    type: "error";
                    text: string | null;
                }>, z.ZodObject<{
                    text: z.ZodNullable<z.ZodString>;
                    type: z.ZodLiteral<"success">;
                }, "strip", z.ZodTypeAny, {
                    type: "success";
                    text: string | null;
                }, {
                    type: "success";
                    text: string | null;
                }>, z.ZodObject<{
                    text: z.ZodNullable<z.ZodString>;
                    type: z.ZodLiteral<"warning">;
                }, "strip", z.ZodTypeAny, {
                    type: "warning";
                    text: string | null;
                }, {
                    type: "warning";
                    text: string | null;
                }>]>>>;
                modelValue: z.ZodNever;
            }, "strip", z.ZodTypeAny, {
                dataTest: string | null;
                label: string | null;
                size: "large" | "medium" | "small" | Kotti.Field.Size | null;
                isDisabled: boolean;
                isLoading: boolean;
                helpText: string | null;
                tabIndex: never;
                modelValue: never;
                placeholder: never;
                hideClear: never;
                hideValidation: boolean;
                showVisibilityToggle: boolean;
                isBorderless: never;
                inputId: string | null;
                formKey: string | null;
                helpDescription: string | null;
                leftIcon: never;
                isOptional: boolean;
                rightIcon: never;
                prefix: never;
                suffix: never;
                validator: (args_0: any, ...args: unknown[]) => {
                    type: "empty";
                } | {
                    type: "error";
                    text: string | null;
                } | {
                    type: "success";
                    text: string | null;
                } | {
                    type: "warning";
                    text: string | null;
                };
            }, {
                tabIndex: never;
                modelValue: never;
                placeholder: never;
                hideClear: never;
                isBorderless: never;
                leftIcon: never;
                rightIcon: never;
                prefix: never;
                suffix: never;
                size?: "large" | "medium" | "small" | Kotti.Field.Size | null | undefined;
                isDisabled?: boolean | undefined;
                isLoading?: boolean | undefined;
                hideValidation?: boolean | undefined;
                inputId?: string | null | undefined;
                dataTest?: string | null | undefined;
                formKey?: string | null | undefined;
                helpDescription?: string | null | undefined;
                helpText?: string | null | undefined;
                isOptional?: boolean | undefined;
                label?: string | null | undefined;
                showVisibilityToggle?: boolean | undefined;
                validator?: ((args_0: any, ...args: unknown[]) => {
                    type: "empty";
                } | {
                    type: "error";
                    text: string | null;
                } | {
                    type: "success";
                    text: string | null;
                } | {
                    type: "warning";
                    text: string | null;
                }) | undefined;
            }>> & Record<string, unknown>;
        };
        ToggleInner: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            component: {
                required: true;
                type: StringConstructor;
            };
            inputProps: {
                required: true;
                type: import("vue").PropType<Kotti.Field.Hook.Returns<KottiFieldToggle.ModelValue>["inputProps"]>;
            };
            isDisabled: {
                required: true;
                type: BooleanConstructor;
            };
            modelValue: {
                default: null;
                type: import("vue").PropType<boolean | null>;
            };
            type: {
                default: string;
                type: StringConstructor;
            };
        }>, {
            onInput: (event: Event) => void;
            svgComponent: import("vue").ComputedRef<{
                class: {
                    'kt-field-toggle-inner__svg': boolean;
                    'kt-field-toggle-inner__svg--is-box': boolean;
                    'kt-field-toggle-inner__svg--is-switch': boolean;
                };
                is: string | undefined;
            }>;
            toggleClasses: import("vue").ComputedRef<{
                'kt-field-toggle-inner--is-disabled': boolean;
                'kt-field-toggle-inner--is-indeterminate': boolean;
                'kt-field-toggle-inner--is-off': boolean;
                'kt-field-toggle-inner--is-on': boolean;
            }>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            component: {
                required: true;
                type: StringConstructor;
            };
            inputProps: {
                required: true;
                type: import("vue").PropType<Kotti.Field.Hook.Returns<KottiFieldToggle.ModelValue>["inputProps"]>;
            };
            isDisabled: {
                required: true;
                type: BooleanConstructor;
            };
            modelValue: {
                default: null;
                type: import("vue").PropType<boolean | null>;
            };
            type: {
                default: string;
                type: StringConstructor;
            };
        }>> & Readonly<{
            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
        }>, {
            type: string;
            modelValue: boolean | null;
        }, {}, {
            ToggleBox: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            ToggleSwitch: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import("vue").ExtractPropTypes<{
        dataTest: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        type: Omit<import("vue").Prop<"switch" | "checkbox" | Kotti.FieldToggle.Shared.Type>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<"switch" | "checkbox" | Kotti.FieldToggle.Shared.Type>;
        } & {
            default: () => "switch" | "checkbox" | Kotti.FieldToggle.Shared.Type;
        };
        label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        size: Omit<import("vue").Prop<"large" | "medium" | "small" | Kotti.Field.Size | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<"large" | "medium" | "small" | Kotti.Field.Size | null>;
        } & {
            default: () => "large" | "medium" | "small" | Kotti.Field.Size | null;
        };
        isDisabled: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        isLoading: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        tabIndex: Omit<import("vue").Prop<number>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<number>;
        } & {
            default: () => number;
        };
        placeholder: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        hideClear: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        hideValidation: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        showVisibilityToggle: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        isBorderless: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        formKey: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<string | null>;
        } & {
            default: () => string | null;
        };
        leftIcon: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        isOptional: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        rightIcon: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        prefix: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        suffix: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<never>;
        } & Record<string, never>;
        validator: Omit<import("vue").Prop<(args_0: any, ...args: unknown[]) => {
            type: "empty";
        } | {
            type: "error";
            text: string | null;
        } | {
            type: "success";
            text: string | null;
        } | {
            type: "warning";
            text: string | null;
        }>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<(args_0: any, ...args: unknown[]) => {
                type: "empty";
            } | {
                type: "error";
                text: string | null;
            } | {
                type: "success";
                text: string | null;
            } | {
                type: "warning";
                text: string | null;
            }>;
        } & {
            default: () => (args_0: any, ...args: unknown[]) => {
                type: "empty";
            } | {
                type: "error";
                text: string | null;
            } | {
                type: "success";
                text: string | null;
            } | {
                type: "warning";
                text: string | null;
            };
        };
        isInline: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<boolean>;
        } & {
            default: () => boolean;
        };
        modelValue: Omit<import("vue").Prop<Record<string, boolean | null> | null>, "type" | "default" | "required"> & {
            required: false;
            type: import("vue").PropType<Record<string, boolean | null> | null>;
        } & {
            default: () => Record<string, boolean | null> | null;
        };
        options: Omit<import("vue").Prop<{
            label: string;
            key: string;
            dataTest?: string | undefined;
            isDisabled?: boolean | undefined;
            tooltip?: string | undefined;
        }[]>, "type" | "default" | "required"> & {
            required: true;
            type: import("vue").PropType<{
                label: string;
                key: string;
                dataTest?: string | undefined;
                isDisabled?: boolean | undefined;
                tooltip?: string | undefined;
            }[]>;
        } & Record<string, never>;
    }>> & Readonly<{
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    }>, {
        field: Kotti.Field.Hook.Returns<Record<string, boolean | null> | null>;
        getOptionDataTest: (option: KottiFieldToggleGroup.Entry) => string | undefined;
        inputProps: import("vue").ComputedRef<(index: number) => {
            forceUpdateKey: number;
            id: string;
            disabled: boolean;
            'data-test': string;
            tabindex: number;
        }>;
        onUpdateModelValue: (key: KottiFieldToggleGroup.Entry["key"], newValue: boolean | undefined) => void;
        optionsWithChecked: import("vue").ComputedRef<{
            value: boolean | null | undefined;
            label: string;
            key: string;
            dataTest?: string | undefined;
            isDisabled?: boolean | undefined;
            tooltip?: string | undefined;
        }[]>;
        wrapperClasses: import("vue").ComputedRef<{
            'kt-field-toggle-group': boolean;
            'kt-field-toggle-group--inline': boolean;
        }>;
    }, {}, {}, {}, {
        dataTest: string | null;
        type: "switch" | "checkbox" | Kotti.FieldToggle.Shared.Type;
        label: string | null;
        size: "large" | "medium" | "small" | Kotti.Field.Size | null;
        isDisabled: boolean;
        isLoading: boolean;
        helpText: string | null;
        tabIndex: number;
        modelValue: Record<string, boolean | null> | null;
        hideValidation: boolean;
        showVisibilityToggle: boolean;
        inputId: string | null;
        formKey: string | null;
        helpDescription: string | null;
        isOptional: boolean;
        validator: (args_0: any, ...args: unknown[]) => {
            type: "empty";
        } | {
            type: "error";
            text: string | null;
        } | {
            type: "success";
            text: string | null;
        } | {
            type: "warning";
            text: string | null;
        };
        isInline: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
    dataTest: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<string | null>;
    } & {
        default: () => string | null;
    };
    type: Omit<import("vue").Prop<"switch" | "checkbox" | Kotti.FieldToggle.Shared.Type>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<"switch" | "checkbox" | Kotti.FieldToggle.Shared.Type>;
    } & {
        default: () => "switch" | "checkbox" | Kotti.FieldToggle.Shared.Type;
    };
    label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<string | null>;
    } & {
        default: () => string | null;
    };
    size: Omit<import("vue").Prop<"large" | "medium" | "small" | Kotti.Field.Size | null>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<"large" | "medium" | "small" | Kotti.Field.Size | null>;
    } & {
        default: () => "large" | "medium" | "small" | Kotti.Field.Size | null;
    };
    isDisabled: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<boolean>;
    } & {
        default: () => boolean;
    };
    isLoading: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<boolean>;
    } & {
        default: () => boolean;
    };
    helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<string | null>;
    } & {
        default: () => string | null;
    };
    tabIndex: Omit<import("vue").Prop<number>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<number>;
    } & {
        default: () => number;
    };
    placeholder: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
        required: true;
        type: import("vue").PropType<never>;
    } & Record<string, never>;
    hideClear: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
        required: true;
        type: import("vue").PropType<never>;
    } & Record<string, never>;
    hideValidation: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<boolean>;
    } & {
        default: () => boolean;
    };
    showVisibilityToggle: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<boolean>;
    } & {
        default: () => boolean;
    };
    isBorderless: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
        required: true;
        type: import("vue").PropType<never>;
    } & Record<string, never>;
    inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<string | null>;
    } & {
        default: () => string | null;
    };
    formKey: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<string | null>;
    } & {
        default: () => string | null;
    };
    helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<string | null>;
    } & {
        default: () => string | null;
    };
    leftIcon: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
        required: true;
        type: import("vue").PropType<never>;
    } & Record<string, never>;
    isOptional: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<boolean>;
    } & {
        default: () => boolean;
    };
    rightIcon: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
        required: true;
        type: import("vue").PropType<never>;
    } & Record<string, never>;
    prefix: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
        required: true;
        type: import("vue").PropType<never>;
    } & Record<string, never>;
    suffix: Omit<import("vue").Prop<never>, "type" | "default" | "required"> & {
        required: true;
        type: import("vue").PropType<never>;
    } & Record<string, never>;
    validator: Omit<import("vue").Prop<(args_0: any, ...args: unknown[]) => {
        type: "empty";
    } | {
        type: "error";
        text: string | null;
    } | {
        type: "success";
        text: string | null;
    } | {
        type: "warning";
        text: string | null;
    }>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<(args_0: any, ...args: unknown[]) => {
            type: "empty";
        } | {
            type: "error";
            text: string | null;
        } | {
            type: "success";
            text: string | null;
        } | {
            type: "warning";
            text: string | null;
        }>;
    } & {
        default: () => (args_0: any, ...args: unknown[]) => {
            type: "empty";
        } | {
            type: "error";
            text: string | null;
        } | {
            type: "success";
            text: string | null;
        } | {
            type: "warning";
            text: string | null;
        };
    };
    isInline: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<boolean>;
    } & {
        default: () => boolean;
    };
    modelValue: Omit<import("vue").Prop<Record<string, boolean | null> | null>, "type" | "default" | "required"> & {
        required: false;
        type: import("vue").PropType<Record<string, boolean | null> | null>;
    } & {
        default: () => Record<string, boolean | null> | null;
    };
    options: Omit<import("vue").Prop<{
        label: string;
        key: string;
        dataTest?: string | undefined;
        isDisabled?: boolean | undefined;
        tooltip?: string | undefined;
    }[]>, "type" | "default" | "required"> & {
        required: true;
        type: import("vue").PropType<{
            label: string;
            key: string;
            dataTest?: string | undefined;
            isDisabled?: boolean | undefined;
            tooltip?: string | undefined;
        }[]>;
    } & Record<string, never>;
}>> & Readonly<{
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
    field: Kotti.Field.Hook.Returns<Record<string, boolean | null> | null>;
    getOptionDataTest: (option: KottiFieldToggleGroup.Entry) => string | undefined;
    inputProps: import("vue").ComputedRef<(index: number) => {
        forceUpdateKey: number;
        id: string;
        disabled: boolean;
        'data-test': string;
        tabindex: number;
    }>;
    onUpdateModelValue: (key: KottiFieldToggleGroup.Entry["key"], newValue: boolean | undefined) => void;
    optionsWithChecked: import("vue").ComputedRef<{
        value: boolean | null | undefined;
        label: string;
        key: string;
        dataTest?: string | undefined;
        isDisabled?: boolean | undefined;
        tooltip?: string | undefined;
    }[]>;
    wrapperClasses: import("vue").ComputedRef<{
        'kt-field-toggle-group': boolean;
        'kt-field-toggle-group--inline': boolean;
    }>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", {
    dataTest: string | null;
    type: "switch" | "checkbox" | Kotti.FieldToggle.Shared.Type;
    label: string | null;
    size: "large" | "medium" | "small" | Kotti.Field.Size | null;
    isDisabled: boolean;
    isLoading: boolean;
    helpText: string | null;
    tabIndex: number;
    modelValue: Record<string, boolean | null> | null;
    hideValidation: boolean;
    showVisibilityToggle: boolean;
    inputId: string | null;
    formKey: string | null;
    helpDescription: string | null;
    isOptional: boolean;
    validator: (args_0: any, ...args: unknown[]) => {
        type: "empty";
    } | {
        type: "error";
        text: string | null;
    } | {
        type: "success";
        text: string | null;
    } | {
        type: "warning";
        text: string | null;
    };
    isInline: boolean;
}, {}, string, {}, {
    FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        helpText: {
            default: null;
            type: import("vue").PropType<string | null>;
        };
        helpTextSlot: {
            default: undefined;
            type: import("vue").PropType<import("vue").Slot<undefined>>;
        };
    }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
        [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        helpText: {
            default: null;
            type: import("vue").PropType<string | null>;
        };
        helpTextSlot: {
            default: undefined;
            type: import("vue").PropType<import("vue").Slot<undefined>>;
        };
    }>> & Readonly<{}>, {
        helpText: string | null;
        helpTextSlot: import("vue").Slot<undefined>;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    KtField: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            debounceLabelClick: {
                default: boolean;
                type: BooleanConstructor;
            };
            field: {
                required: true;
                type: import("vue").PropType<Kotti.Field.Hook.Returns<unknown>>;
            };
            getEmptyValue: {
                default: null;
                type: import("vue").PropType<() => unknown>;
            };
            helpTextSlot: {
                default: undefined;
                type: import("vue").PropType<import("vue").Slot<undefined>>;
            };
            isRange: {
                default: boolean;
                type: BooleanConstructor;
            };
            useFieldset: {
                default: boolean;
                type: BooleanConstructor;
            };
        }>> & Readonly<{
            onClick?: ((...args: any[]) => any) | undefined;
            onMousedown?: ((...args: any[]) => any) | undefined;
            onVisibilityChange?: ((...args: any[]) => any) | undefined;
        }>, {
            affixClasses: import("vue").ComputedRef<(modifications: string[]) => string[]>;
            focusInput: () => void;
            handleClear: () => void;
            handleVisibilityChange: () => void;
            iconClasses: import("vue").ComputedRef<(element: string, modifications: string[]) => string[]>;
            inputId: import("vue").ComputedRef<string>;
            inputContainerRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
            inputContainerWrapperRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
            onClickLabel: (event: MouseEvent) => void;
            showLabel: import("vue").ComputedRef<true | import("vue").Slot<undefined> | undefined>;
            showValidation: import("vue").ComputedRef<boolean>;
            validationState: import("vue").ComputedRef<"error" | "empty">;
            validationText: import("vue").ComputedRef<string | null>;
            validationTextIcon: import("vue").ComputedRef<import("@3yourmind/yoco").Yoco.Icon | null>;
            valueVisibility: import("vue").Ref<boolean, boolean>;
            wrapperClasses: import("vue").ComputedRef<string[]>;
            Yoco: typeof import("@3yourmind/yoco").Yoco;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "mousedown" | "visibilityChange")[], import("vue").PublicProps, {
            helpTextSlot: import("vue").Slot<undefined>;
            debounceLabelClick: boolean;
            getEmptyValue: () => unknown;
            isRange: boolean;
            useFieldset: boolean;
        }, true, {}, {}, {
            FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                helpText: {
                    default: null;
                    type: import("vue").PropType<string | null>;
                };
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
            }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                [key: string]: any;
            }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                helpText: {
                    default: null;
                    type: import("vue").PropType<string | null>;
                };
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
            }>> & Readonly<{}>, {
                helpText: string | null;
                helpTextSlot: import("vue").Slot<undefined>;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            KtLabel: {
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                    label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<boolean>;
                    } & {
                        default: () => boolean;
                    };
                    validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                    } & {
                        default: () => "error" | "success" | "warning" | "empty";
                    };
                }>> & Readonly<{
                    onClick?: ((...args: any[]) => any) | undefined;
                }>, {
                    hasHelpText: import("vue").ComputedRef<boolean>;
                    labelSuffix: import("vue").ComputedRef<"*" | null>;
                    labelSuffixClasses: import("vue").ComputedRef<{
                        [x: string]: boolean;
                        'kt-label__header-label-suffix': boolean;
                    }>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], import("vue").PublicProps, {
                    label: string | null;
                    helpText: string | null;
                    inputId: string | null;
                    helpDescription: string | null;
                    helpTextSlot: import("vue").Slot<undefined>;
                    isRequired: boolean;
                    validationState: "error" | "success" | "warning" | "empty";
                }, true, {}, {}, {
                    FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        helpText: {
                            default: null;
                            type: import("vue").PropType<string | null>;
                        };
                        helpTextSlot: {
                            default: undefined;
                            type: import("vue").PropType<import("vue").Slot<undefined>>;
                        };
                    }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                        [key: string]: any;
                    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        helpText: {
                            default: null;
                            type: import("vue").PropType<string | null>;
                        };
                        helpTextSlot: {
                            default: undefined;
                            type: import("vue").PropType<import("vue").Slot<undefined>>;
                        };
                    }>> & Readonly<{}>, {
                        helpText: string | null;
                        helpTextSlot: import("vue").Slot<undefined>;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import("vue").ExtractPropTypes<{
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                    label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<string | null>;
                    } & {
                        default: () => string | null;
                    };
                    isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<boolean>;
                    } & {
                        default: () => boolean;
                    };
                    validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                    } & {
                        default: () => "error" | "success" | "warning" | "empty";
                    };
                }>> & Readonly<{
                    onClick?: ((...args: any[]) => any) | undefined;
                }>, {
                    hasHelpText: import("vue").ComputedRef<boolean>;
                    labelSuffix: import("vue").ComputedRef<"*" | null>;
                    labelSuffixClasses: import("vue").ComputedRef<{
                        [x: string]: boolean;
                        'kt-label__header-label-suffix': boolean;
                    }>;
                }, {}, {}, {}, {
                    label: string | null;
                    helpText: string | null;
                    inputId: string | null;
                    helpDescription: string | null;
                    helpTextSlot: import("vue").Slot<undefined>;
                    isRequired: boolean;
                    validationState: "error" | "success" | "warning" | "empty";
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
                label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<boolean>;
                } & {
                    default: () => boolean;
                };
                validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                } & {
                    default: () => "error" | "success" | "warning" | "empty";
                };
            }>> & Readonly<{
                onClick?: ((...args: any[]) => any) | undefined;
            }>, {
                hasHelpText: import("vue").ComputedRef<boolean>;
                labelSuffix: import("vue").ComputedRef<"*" | null>;
                labelSuffixClasses: import("vue").ComputedRef<{
                    [x: string]: boolean;
                    'kt-label__header-label-suffix': boolean;
                }>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", {
                label: string | null;
                helpText: string | null;
                inputId: string | null;
                helpDescription: string | null;
                helpTextSlot: import("vue").Slot<undefined>;
                isRequired: boolean;
                validationState: "error" | "success" | "warning" | "empty";
            }, {}, string, {}, {
                FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    helpText: {
                        default: null;
                        type: import("vue").PropType<string | null>;
                    };
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    helpText: {
                        default: null;
                        type: import("vue").PropType<string | null>;
                    };
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                }>> & Readonly<{}>, {
                    helpText: string | null;
                    helpTextSlot: import("vue").Slot<undefined>;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                install: import("vue").FunctionPlugin<Record<string, never>>;
            } & {
                meta: Kotti.Meta<z.ZodObject<{
                    label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    helpText: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    helpDescription: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    inputId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                    isRequired: z.ZodDefault<z.ZodBoolean>;
                    validationState: z.ZodDefault<z.ZodEnum<["empty", "error", "success", "warning"]>>;
                }, "strip", z.ZodTypeAny, {
                    label: string | null;
                    helpText: string | null;
                    inputId: string | null;
                    helpDescription: string | null;
                    isRequired: boolean;
                    validationState: "error" | "success" | "warning" | "empty";
                }, {
                    label?: string | null | undefined;
                    helpText?: string | null | undefined;
                    helpDescription?: string | null | undefined;
                    inputId?: string | null | undefined;
                    isRequired?: boolean | undefined;
                    validationState?: "error" | "success" | "warning" | "empty" | undefined;
                }>> & Record<string, unknown>;
            };
            KtLoading: {
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                    type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                    } & {
                        default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                    };
                }>> & Readonly<{}>, {
                    loadingClasses: import("vue").ComputedRef<string>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
                    type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import("vue").ExtractPropTypes<{
                    type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                        required: false;
                        type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                    } & {
                        default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                    };
                }>> & Readonly<{}>, {
                    loadingClasses: import("vue").ComputedRef<string>;
                }, {}, {}, {}, {
                    type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                } & {
                    default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                };
            }>> & Readonly<{}>, {
                loadingClasses: import("vue").ComputedRef<string>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
                type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                install: import("vue").FunctionPlugin<Record<string, never>>;
            } & {
                meta: Kotti.Meta<z.ZodObject<{
                    type: z.ZodDefault<z.ZodEnum<["circle", "rectangle", "rectangle-lg", "rectangle-md", "rectangle-sm", "square"]>>;
                }, "strip", z.ZodTypeAny, {
                    type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                }, {
                    type?: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square" | undefined;
                }>> & Record<string, unknown>;
            };
        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            debounceLabelClick: {
                default: boolean;
                type: BooleanConstructor;
            };
            field: {
                required: true;
                type: import("vue").PropType<Kotti.Field.Hook.Returns<unknown>>;
            };
            getEmptyValue: {
                default: null;
                type: import("vue").PropType<() => unknown>;
            };
            helpTextSlot: {
                default: undefined;
                type: import("vue").PropType<import("vue").Slot<undefined>>;
            };
            isRange: {
                default: boolean;
                type: BooleanConstructor;
            };
            useFieldset: {
                default: boolean;
                type: BooleanConstructor;
            };
        }>> & Readonly<{
            onClick?: ((...args: any[]) => any) | undefined;
            onMousedown?: ((...args: any[]) => any) | undefined;
            onVisibilityChange?: ((...args: any[]) => any) | undefined;
        }>, {
            affixClasses: import("vue").ComputedRef<(modifications: string[]) => string[]>;
            focusInput: () => void;
            handleClear: () => void;
            handleVisibilityChange: () => void;
            iconClasses: import("vue").ComputedRef<(element: string, modifications: string[]) => string[]>;
            inputId: import("vue").ComputedRef<string>;
            inputContainerRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
            inputContainerWrapperRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
            onClickLabel: (event: MouseEvent) => void;
            showLabel: import("vue").ComputedRef<true | import("vue").Slot<undefined> | undefined>;
            showValidation: import("vue").ComputedRef<boolean>;
            validationState: import("vue").ComputedRef<"error" | "empty">;
            validationText: import("vue").ComputedRef<string | null>;
            validationTextIcon: import("vue").ComputedRef<import("@3yourmind/yoco").Yoco.Icon | null>;
            valueVisibility: import("vue").Ref<boolean, boolean>;
            wrapperClasses: import("vue").ComputedRef<string[]>;
            Yoco: typeof import("@3yourmind/yoco").Yoco;
        }, {}, {}, {}, {
            helpTextSlot: import("vue").Slot<undefined>;
            debounceLabelClick: boolean;
            getEmptyValue: () => unknown;
            isRange: boolean;
            useFieldset: boolean;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
        debounceLabelClick: {
            default: boolean;
            type: BooleanConstructor;
        };
        field: {
            required: true;
            type: import("vue").PropType<Kotti.Field.Hook.Returns<unknown>>;
        };
        getEmptyValue: {
            default: null;
            type: import("vue").PropType<() => unknown>;
        };
        helpTextSlot: {
            default: undefined;
            type: import("vue").PropType<import("vue").Slot<undefined>>;
        };
        isRange: {
            default: boolean;
            type: BooleanConstructor;
        };
        useFieldset: {
            default: boolean;
            type: BooleanConstructor;
        };
    }>> & Readonly<{
        onClick?: ((...args: any[]) => any) | undefined;
        onMousedown?: ((...args: any[]) => any) | undefined;
        onVisibilityChange?: ((...args: any[]) => any) | undefined;
    }>, {
        affixClasses: import("vue").ComputedRef<(modifications: string[]) => string[]>;
        focusInput: () => void;
        handleClear: () => void;
        handleVisibilityChange: () => void;
        iconClasses: import("vue").ComputedRef<(element: string, modifications: string[]) => string[]>;
        inputId: import("vue").ComputedRef<string>;
        inputContainerRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
        inputContainerWrapperRef: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
        onClickLabel: (event: MouseEvent) => void;
        showLabel: import("vue").ComputedRef<true | import("vue").Slot<undefined> | undefined>;
        showValidation: import("vue").ComputedRef<boolean>;
        validationState: import("vue").ComputedRef<"error" | "empty">;
        validationText: import("vue").ComputedRef<string | null>;
        validationTextIcon: import("vue").ComputedRef<import("@3yourmind/yoco").Yoco.Icon | null>;
        valueVisibility: import("vue").Ref<boolean, boolean>;
        wrapperClasses: import("vue").ComputedRef<string[]>;
        Yoco: typeof import("@3yourmind/yoco").Yoco;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "mousedown" | "visibilityChange")[], "click" | "mousedown" | "visibilityChange", {
        helpTextSlot: import("vue").Slot<undefined>;
        debounceLabelClick: boolean;
        getEmptyValue: () => unknown;
        isRange: boolean;
        useFieldset: boolean;
    }, {}, string, {}, {
        FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            helpText: {
                default: null;
                type: import("vue").PropType<string | null>;
            };
            helpTextSlot: {
                default: undefined;
                type: import("vue").PropType<import("vue").Slot<undefined>>;
            };
        }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            helpText: {
                default: null;
                type: import("vue").PropType<string | null>;
            };
            helpTextSlot: {
                default: undefined;
                type: import("vue").PropType<import("vue").Slot<undefined>>;
            };
        }>> & Readonly<{}>, {
            helpText: string | null;
            helpTextSlot: import("vue").Slot<undefined>;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        KtLabel: {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
                label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<boolean>;
                } & {
                    default: () => boolean;
                };
                validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                } & {
                    default: () => "error" | "success" | "warning" | "empty";
                };
            }>> & Readonly<{
                onClick?: ((...args: any[]) => any) | undefined;
            }>, {
                hasHelpText: import("vue").ComputedRef<boolean>;
                labelSuffix: import("vue").ComputedRef<"*" | null>;
                labelSuffixClasses: import("vue").ComputedRef<{
                    [x: string]: boolean;
                    'kt-label__header-label-suffix': boolean;
                }>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], import("vue").PublicProps, {
                label: string | null;
                helpText: string | null;
                inputId: string | null;
                helpDescription: string | null;
                helpTextSlot: import("vue").Slot<undefined>;
                isRequired: boolean;
                validationState: "error" | "success" | "warning" | "empty";
            }, true, {}, {}, {
                FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    helpText: {
                        default: null;
                        type: import("vue").PropType<string | null>;
                    };
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    helpText: {
                        default: null;
                        type: import("vue").PropType<string | null>;
                    };
                    helpTextSlot: {
                        default: undefined;
                        type: import("vue").PropType<import("vue").Slot<undefined>>;
                    };
                }>> & Readonly<{}>, {
                    helpText: string | null;
                    helpTextSlot: import("vue").Slot<undefined>;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("vue").ExtractPropTypes<{
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
                label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<string | null>;
                } & {
                    default: () => string | null;
                };
                isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<boolean>;
                } & {
                    default: () => boolean;
                };
                validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
                } & {
                    default: () => "error" | "success" | "warning" | "empty";
                };
            }>> & Readonly<{
                onClick?: ((...args: any[]) => any) | undefined;
            }>, {
                hasHelpText: import("vue").ComputedRef<boolean>;
                labelSuffix: import("vue").ComputedRef<"*" | null>;
                labelSuffixClasses: import("vue").ComputedRef<{
                    [x: string]: boolean;
                    'kt-label__header-label-suffix': boolean;
                }>;
            }, {}, {}, {}, {
                label: string | null;
                helpText: string | null;
                inputId: string | null;
                helpDescription: string | null;
                helpTextSlot: import("vue").Slot<undefined>;
                isRequired: boolean;
                validationState: "error" | "success" | "warning" | "empty";
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            helpTextSlot: {
                default: undefined;
                type: import("vue").PropType<import("vue").Slot<undefined>>;
            };
            label: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                required: false;
                type: import("vue").PropType<string | null>;
            } & {
                default: () => string | null;
            };
            helpText: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                required: false;
                type: import("vue").PropType<string | null>;
            } & {
                default: () => string | null;
            };
            helpDescription: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                required: false;
                type: import("vue").PropType<string | null>;
            } & {
                default: () => string | null;
            };
            inputId: Omit<import("vue").Prop<string | null>, "type" | "default" | "required"> & {
                required: false;
                type: import("vue").PropType<string | null>;
            } & {
                default: () => string | null;
            };
            isRequired: Omit<import("vue").Prop<boolean>, "type" | "default" | "required"> & {
                required: false;
                type: import("vue").PropType<boolean>;
            } & {
                default: () => boolean;
            };
            validationState: Omit<import("vue").Prop<"error" | "success" | "warning" | "empty">, "type" | "default" | "required"> & {
                required: false;
                type: import("vue").PropType<"error" | "success" | "warning" | "empty">;
            } & {
                default: () => "error" | "success" | "warning" | "empty";
            };
        }>> & Readonly<{
            onClick?: ((...args: any[]) => any) | undefined;
        }>, {
            hasHelpText: import("vue").ComputedRef<boolean>;
            labelSuffix: import("vue").ComputedRef<"*" | null>;
            labelSuffixClasses: import("vue").ComputedRef<{
                [x: string]: boolean;
                'kt-label__header-label-suffix': boolean;
            }>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", {
            label: string | null;
            helpText: string | null;
            inputId: string | null;
            helpDescription: string | null;
            helpTextSlot: import("vue").Slot<undefined>;
            isRequired: boolean;
            validationState: "error" | "success" | "warning" | "empty";
        }, {}, string, {}, {
            FieldHelpText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                helpText: {
                    default: null;
                    type: import("vue").PropType<string | null>;
                };
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
            }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                [key: string]: any;
            }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                helpText: {
                    default: null;
                    type: import("vue").PropType<string | null>;
                };
                helpTextSlot: {
                    default: undefined;
                    type: import("vue").PropType<import("vue").Slot<undefined>>;
                };
            }>> & Readonly<{}>, {
                helpText: string | null;
                helpTextSlot: import("vue").Slot<undefined>;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
            install: import("vue").FunctionPlugin<Record<string, never>>;
        } & {
            meta: Kotti.Meta<z.ZodObject<{
                label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                helpText: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                helpDescription: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                inputId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
                isRequired: z.ZodDefault<z.ZodBoolean>;
                validationState: z.ZodDefault<z.ZodEnum<["empty", "error", "success", "warning"]>>;
            }, "strip", z.ZodTypeAny, {
                label: string | null;
                helpText: string | null;
                inputId: string | null;
                helpDescription: string | null;
                isRequired: boolean;
                validationState: "error" | "success" | "warning" | "empty";
            }, {
                label?: string | null | undefined;
                helpText?: string | null | undefined;
                helpDescription?: string | null | undefined;
                inputId?: string | null | undefined;
                isRequired?: boolean | undefined;
                validationState?: "error" | "success" | "warning" | "empty" | undefined;
            }>> & Record<string, unknown>;
        };
        KtLoading: {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                } & {
                    default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                };
            }>> & Readonly<{}>, {
                loadingClasses: import("vue").ComputedRef<string>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
                type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
            }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("vue").ExtractPropTypes<{
                type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                    required: false;
                    type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
                } & {
                    default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
                };
            }>> & Readonly<{}>, {
                loadingClasses: import("vue").ComputedRef<string>;
            }, {}, {}, {}, {
                type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            type: Omit<import("vue").Prop<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">, "type" | "default" | "required"> & {
                required: false;
                type: import("vue").PropType<"circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square">;
            } & {
                default: () => "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
            };
        }>> & Readonly<{}>, {
            loadingClasses: import("vue").ComputedRef<string>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
            type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
            install: import("vue").FunctionPlugin<Record<string, never>>;
        } & {
            meta: Kotti.Meta<z.ZodObject<{
                type: z.ZodDefault<z.ZodEnum<["circle", "rectangle", "rectangle-lg", "rectangle-md", "rectangle-sm", "square"]>>;
            }, "strip", z.ZodTypeAny, {
                type: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square";
            }, {
                type?: "circle" | "rectangle" | "rectangle-lg" | "rectangle-md" | "rectangle-sm" | "square" | undefined;
            }>> & Record<string, unknown>;
        };
    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
        install: import("vue").FunctionPlugin<Record<string, never>>;
    } & {
        meta: Kotti.Meta<z.ZodObject<{
            size: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodEnum<["large" | "medium" | "small", ...("large" | "medium" | "small")[]]>, z.ZodNativeEnum<typeof Kotti.Field.Size>]>>>;
            isDisabled: z.ZodDefault<z.ZodBoolean>;
            isLoading: z.ZodDefault<z.ZodBoolean>;
            hideClear: z.ZodNever;
            hideValidation: z.ZodDefault<z.ZodBoolean>;
            isBorderless: z.ZodNever;
            inputId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            dataTest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            formKey: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodLiteral<"NONE">]>>>;
            helpDescription: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            helpText: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            leftIcon: z.ZodNever;
            placeholder: z.ZodNever;
            isOptional: z.ZodDefault<z.ZodBoolean>;
            label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
            rightIcon: z.ZodNever;
            prefix: z.ZodNever;
            showVisibilityToggle: z.ZodDefault<z.ZodBoolean>;
            suffix: z.ZodNever;
            tabIndex: z.ZodNever;
            validator: z.ZodDefault<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodUnion<[z.ZodObject<{
                type: z.ZodLiteral<"empty">;
            }, "strip", z.ZodTypeAny, {
                type: "empty";
            }, {
                type: "empty";
            }>, z.ZodObject<{
                text: z.ZodNullable<z.ZodString>;
                type: z.ZodLiteral<"error">;
            }, "strip", z.ZodTypeAny, {
                type: "error";
                text: string | null;
            }, {
                type: "error";
                text: string | null;
            }>, z.ZodObject<{
                text: z.ZodNullable<z.ZodString>;
                type: z.ZodLiteral<"success">;
            }, "strip", z.ZodTypeAny, {
                type: "success";
                text: string | null;
            }, {
                type: "success";
                text: string | null;
            }>, z.ZodObject<{
                text: z.ZodNullable<z.ZodString>;
                type: z.ZodLiteral<"warning">;
            }, "strip", z.ZodTypeAny, {
                type: "warning";
                text: string | null;
            }, {
                type: "warning";
                text: string | null;
            }>]>>>;
            modelValue: z.ZodNever;
        }, "strip", z.ZodTypeAny, {
            dataTest: string | null;
            label: string | null;
            size: "large" | "medium" | "small" | Kotti.Field.Size | null;
            isDisabled: boolean;
            isLoading: boolean;
            helpText: string | null;
            tabIndex: never;
            modelValue: never;
            placeholder: never;
            hideClear: never;
            hideValidation: boolean;
            showVisibilityToggle: boolean;
            isBorderless: never;
            inputId: string | null;
            formKey: string | null;
            helpDescription: string | null;
            leftIcon: never;
            isOptional: boolean;
            rightIcon: never;
            prefix: never;
            suffix: never;
            validator: (args_0: any, ...args: unknown[]) => {
                type: "empty";
            } | {
                type: "error";
                text: string | null;
            } | {
                type: "success";
                text: string | null;
            } | {
                type: "warning";
                text: string | null;
            };
        }, {
            tabIndex: never;
            modelValue: never;
            placeholder: never;
            hideClear: never;
            isBorderless: never;
            leftIcon: never;
            rightIcon: never;
            prefix: never;
            suffix: never;
            size?: "large" | "medium" | "small" | Kotti.Field.Size | null | undefined;
            isDisabled?: boolean | undefined;
            isLoading?: boolean | undefined;
            hideValidation?: boolean | undefined;
            inputId?: string | null | undefined;
            dataTest?: string | null | undefined;
            formKey?: string | null | undefined;
            helpDescription?: string | null | undefined;
            helpText?: string | null | undefined;
            isOptional?: boolean | undefined;
            label?: string | null | undefined;
            showVisibilityToggle?: boolean | undefined;
            validator?: ((args_0: any, ...args: unknown[]) => {
                type: "empty";
            } | {
                type: "error";
                text: string | null;
            } | {
                type: "success";
                text: string | null;
            } | {
                type: "warning";
                text: string | null;
            }) | undefined;
        }>> & Record<string, unknown>;
    };
    ToggleInner: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        component: {
            required: true;
            type: StringConstructor;
        };
        inputProps: {
            required: true;
            type: import("vue").PropType<Kotti.Field.Hook.Returns<KottiFieldToggle.ModelValue>["inputProps"]>;
        };
        isDisabled: {
            required: true;
            type: BooleanConstructor;
        };
        modelValue: {
            default: null;
            type: import("vue").PropType<boolean | null>;
        };
        type: {
            default: string;
            type: StringConstructor;
        };
    }>, {
        onInput: (event: Event) => void;
        svgComponent: import("vue").ComputedRef<{
            class: {
                'kt-field-toggle-inner__svg': boolean;
                'kt-field-toggle-inner__svg--is-box': boolean;
                'kt-field-toggle-inner__svg--is-switch': boolean;
            };
            is: string | undefined;
        }>;
        toggleClasses: import("vue").ComputedRef<{
            'kt-field-toggle-inner--is-disabled': boolean;
            'kt-field-toggle-inner--is-indeterminate': boolean;
            'kt-field-toggle-inner--is-off': boolean;
            'kt-field-toggle-inner--is-on': boolean;
        }>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        component: {
            required: true;
            type: StringConstructor;
        };
        inputProps: {
            required: true;
            type: import("vue").PropType<Kotti.Field.Hook.Returns<KottiFieldToggle.ModelValue>["inputProps"]>;
        };
        isDisabled: {
            required: true;
            type: BooleanConstructor;
        };
        modelValue: {
            default: null;
            type: import("vue").PropType<boolean | null>;
        };
        type: {
            default: string;
            type: StringConstructor;
        };
    }>> & Readonly<{
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    }>, {
        type: string;
        modelValue: boolean | null;
    }, {}, {
        ToggleBox: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        ToggleSwitch: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
} & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
    install: import("vue").FunctionPlugin<Record<string, never>>;
} & {
    meta: Kotti.Meta<z.ZodObject<{
        dataTest: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        type: z.ZodDefault<z.ZodUnion<[z.ZodEnum<["switch" | "checkbox", ...("switch" | "checkbox")[]]>, z.ZodNativeEnum<typeof Kotti.FieldToggle.Shared.Type>]>>;
        label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        size: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodEnum<["large" | "medium" | "small", ...("large" | "medium" | "small")[]]>, z.ZodNativeEnum<typeof Kotti.Field.Size>]>>>;
        isDisabled: z.ZodDefault<z.ZodBoolean>;
        isLoading: z.ZodDefault<z.ZodBoolean>;
        helpText: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        tabIndex: z.ZodDefault<z.ZodNumber>;
        placeholder: z.ZodNever;
        hideClear: z.ZodNever;
        hideValidation: z.ZodDefault<z.ZodBoolean>;
        showVisibilityToggle: z.ZodDefault<z.ZodBoolean>;
        isBorderless: z.ZodNever;
        inputId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        formKey: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodLiteral<"NONE">]>>>;
        helpDescription: z.ZodDefault<z.ZodNullable<z.ZodString>>;
        leftIcon: z.ZodNever;
        isOptional: z.ZodDefault<z.ZodBoolean>;
        rightIcon: z.ZodNever;
        prefix: z.ZodNever;
        suffix: z.ZodNever;
        validator: z.ZodDefault<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodUnion<[z.ZodObject<{
            type: z.ZodLiteral<"empty">;
        }, "strip", z.ZodTypeAny, {
            type: "empty";
        }, {
            type: "empty";
        }>, z.ZodObject<{
            text: z.ZodNullable<z.ZodString>;
            type: z.ZodLiteral<"error">;
        }, "strip", z.ZodTypeAny, {
            type: "error";
            text: string | null;
        }, {
            type: "error";
            text: string | null;
        }>, z.ZodObject<{
            text: z.ZodNullable<z.ZodString>;
            type: z.ZodLiteral<"success">;
        }, "strip", z.ZodTypeAny, {
            type: "success";
            text: string | null;
        }, {
            type: "success";
            text: string | null;
        }>, z.ZodObject<{
            text: z.ZodNullable<z.ZodString>;
            type: z.ZodLiteral<"warning">;
        }, "strip", z.ZodTypeAny, {
            type: "warning";
            text: string | null;
        }, {
            type: "warning";
            text: string | null;
        }>]>>>;
        isInline: z.ZodDefault<z.ZodBoolean>;
        modelValue: z.ZodDefault<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodBoolean>>>>;
        options: z.ZodEffects<z.ZodEffects<z.ZodArray<z.ZodObject<{
            dataTest: z.ZodOptional<z.ZodString>;
            isDisabled: z.ZodOptional<z.ZodBoolean>;
            key: z.ZodString;
            label: z.ZodString;
            tooltip: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            label: string;
            key: string;
            dataTest?: string | undefined;
            isDisabled?: boolean | undefined;
            tooltip?: string | undefined;
        }, {
            label: string;
            key: string;
            dataTest?: string | undefined;
            isDisabled?: boolean | undefined;
            tooltip?: string | undefined;
        }>, "many">, {
            label: string;
            key: string;
            dataTest?: string | undefined;
            isDisabled?: boolean | undefined;
            tooltip?: string | undefined;
        }[], {
            label: string;
            key: string;
            dataTest?: string | undefined;
            isDisabled?: boolean | undefined;
            tooltip?: string | undefined;
        }[]>, {
            label: string;
            key: string;
            dataTest?: string | undefined;
            isDisabled?: boolean | undefined;
            tooltip?: string | undefined;
        }[], {
            label: string;
            key: string;
            dataTest?: string | undefined;
            isDisabled?: boolean | undefined;
            tooltip?: string | undefined;
        }[]>;
    }, "strip", z.ZodTypeAny, {
        dataTest: string | null;
        options: {
            label: string;
            key: string;
            dataTest?: string | undefined;
            isDisabled?: boolean | undefined;
            tooltip?: string | undefined;
        }[];
        type: "switch" | "checkbox" | Kotti.FieldToggle.Shared.Type;
        label: string | null;
        size: "large" | "medium" | "small" | Kotti.Field.Size | null;
        isDisabled: boolean;
        isLoading: boolean;
        helpText: string | null;
        tabIndex: number;
        modelValue: Record<string, boolean | null> | null;
        placeholder: never;
        hideClear: never;
        hideValidation: boolean;
        showVisibilityToggle: boolean;
        isBorderless: never;
        inputId: string | null;
        formKey: string | null;
        helpDescription: string | null;
        leftIcon: never;
        isOptional: boolean;
        rightIcon: never;
        prefix: never;
        suffix: never;
        validator: (args_0: any, ...args: unknown[]) => {
            type: "empty";
        } | {
            type: "error";
            text: string | null;
        } | {
            type: "success";
            text: string | null;
        } | {
            type: "warning";
            text: string | null;
        };
        isInline: boolean;
    }, {
        options: {
            label: string;
            key: string;
            dataTest?: string | undefined;
            isDisabled?: boolean | undefined;
            tooltip?: string | undefined;
        }[];
        placeholder: never;
        hideClear: never;
        isBorderless: never;
        leftIcon: never;
        rightIcon: never;
        prefix: never;
        suffix: never;
        dataTest?: string | null | undefined;
        type?: "switch" | "checkbox" | Kotti.FieldToggle.Shared.Type | undefined;
        label?: string | null | undefined;
        size?: "large" | "medium" | "small" | Kotti.Field.Size | null | undefined;
        isDisabled?: boolean | undefined;
        isLoading?: boolean | undefined;
        helpText?: string | null | undefined;
        tabIndex?: number | undefined;
        hideValidation?: boolean | undefined;
        showVisibilityToggle?: boolean | undefined;
        inputId?: string | null | undefined;
        formKey?: string | null | undefined;
        helpDescription?: string | null | undefined;
        isOptional?: boolean | undefined;
        validator?: ((args_0: any, ...args: unknown[]) => {
            type: "empty";
        } | {
            type: "error";
            text: string | null;
        } | {
            type: "success";
            text: string | null;
        } | {
            type: "warning";
            text: string | null;
        }) | undefined;
        isInline?: boolean | undefined;
        modelValue?: Record<string, boolean | null> | null | undefined;
    }>> & {
        supports: Kotti.Field.Supports;
    };
};
export * from './constants';