@kong-ui-public/forms 4.15.4-pr.2204.f9043269d.0 → 4.15.4-pr.2289.890e582c0.0

package/dist/types/components/FormGenerator.vue.d.ts

@@ -1,487 +0,0 @@
-declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    schema: {
-        type: ObjectConstructor;
-        default: () => undefined;
-    };
-    model: {
-        type: ObjectConstructor;
-        default: () => undefined;
-    };
-    options: {
-        type: ObjectConstructor;
-        default(): {
-            validateAfterLoad: boolean;
-            validateAfterChanged: boolean;
-            child: import("vue").Ref<never[], never[]>;
-            fieldIdPrefix: string;
-            validateAsync: boolean;
-            validationErrorClass: string;
-            validationSuccessClass: string;
-            helpAsHtml: boolean;
-        };
-    };
-    multiple: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    isNewModel: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    tag: {
-        type: StringConstructor;
-        default: string;
-        validator: (value: unknown) => boolean;
-    };
-    enableRedisPartial: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    isEditing: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}>, {}, {
-    vfg: import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
-        schema: {
-            type: ObjectConstructor;
-            default: () => undefined;
-        };
-        model: {
-            type: ObjectConstructor;
-            default: () => undefined;
-        };
-        options: {
-            type: ObjectConstructor;
-            default(): {
-                validateAfterLoad: boolean;
-                validateAfterChanged: boolean;
-                child: import("vue").Ref<never[], never[]>;
-                fieldIdPrefix: string;
-                validateAsync: boolean;
-                validationErrorClass: string;
-                validationSuccessClass: string;
-                helpAsHtml: boolean;
-            };
-        };
-        multiple: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-        isNewModel: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-        tag: {
-            type: StringConstructor;
-            default: string;
-            validator: (value: unknown) => boolean;
-        };
-        enableRedisPartial: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-        isEditing: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-    }>> & Readonly<{
-        onModelUpdated?: ((...args: any[]) => any) | undefined;
-        onRefreshModel?: ((...args: any[]) => any) | undefined;
-        onValidated?: ((...args: any[]) => any) | undefined;
-        onPartialToggled?: ((...args: any[]) => any) | undefined;
-        onShowNewPartialModal?: ((...args: any[]) => any) | undefined;
-    }>, {}, {}, {}, import("vue").MethodOptions, import("vue").DefineComponent<{}, {}, {}, {}, {
-        getFieldRowClasses(field: any): any;
-        fieldErrors(field: any): any;
-        fieldDisabled(field: any): any;
-        fieldReadonly(field: any): any;
-        fieldFeatured(field: any): any;
-        fieldRequired(field: any): any;
-    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, import("vue").ComponentOptionsMixin, {}, Readonly<import("vue").ExtractPropTypes<{
-        schema: {
-            type: ObjectConstructor;
-            default: () => undefined;
-        };
-        model: {
-            type: ObjectConstructor;
-            default: () => undefined;
-        };
-        options: {
-            type: ObjectConstructor;
-            default(): {
-                validateAfterLoad: boolean;
-                validateAfterChanged: boolean;
-                child: import("vue").Ref<never[], never[]>;
-                fieldIdPrefix: string;
-                validateAsync: boolean;
-                validationErrorClass: string;
-                validationSuccessClass: string;
-                helpAsHtml: boolean;
-            };
-        };
-        multiple: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-        isNewModel: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-        tag: {
-            type: StringConstructor;
-            default: string;
-            validator: (value: unknown) => boolean;
-        };
-        enableRedisPartial: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-        isEditing: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-    }>> & Readonly<{
-        onModelUpdated?: ((...args: any[]) => any) | undefined;
-        onRefreshModel?: ((...args: any[]) => any) | undefined;
-        onValidated?: ((...args: any[]) => any) | undefined;
-        onPartialToggled?: ((...args: any[]) => any) | undefined;
-        onShowNewPartialModal?: ((...args: any[]) => any) | undefined;
-    }>, {}, false, {}, {}, {}, {}, string, {}, any, import("vue").ComponentProvideOptions, {
-        P: Readonly<{}> & Readonly<{}>;
-        B: {};
-        D: {};
-        C: {};
-        M: {
-            getFieldRowClasses(field: any): any;
-            fieldErrors(field: any): any;
-            fieldDisabled(field: any): any;
-            fieldReadonly(field: any): any;
-            fieldFeatured(field: any): any;
-            fieldRequired(field: any): any;
-        };
-        Defaults: {};
-    } & {
-        P: {};
-        B: {};
-        D: {};
-        C: {};
-        M: {};
-        Defaults: {};
-    }, Readonly<{}> & Readonly<{}> & Readonly<import("vue").ExtractPropTypes<{
-        schema: {
-            type: ObjectConstructor;
-            default: () => undefined;
-        };
-        model: {
-            type: ObjectConstructor;
-            default: () => undefined;
-        };
-        options: {
-            type: ObjectConstructor;
-            default(): {
-                validateAfterLoad: boolean;
-                validateAfterChanged: boolean;
-                child: import("vue").Ref<never[], never[]>;
-                fieldIdPrefix: string;
-                validateAsync: boolean;
-                validationErrorClass: string;
-                validationSuccessClass: string;
-                helpAsHtml: boolean;
-            };
-        };
-        multiple: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-        isNewModel: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-        tag: {
-            type: StringConstructor;
-            default: string;
-            validator: (value: unknown) => boolean;
-        };
-        enableRedisPartial: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-        isEditing: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-    }>> & Readonly<{
-        onModelUpdated?: ((...args: any[]) => any) | undefined;
-        onRefreshModel?: ((...args: any[]) => any) | undefined;
-        onValidated?: ((...args: any[]) => any) | undefined;
-        onPartialToggled?: ((...args: any[]) => any) | undefined;
-        onShowNewPartialModal?: ((...args: any[]) => any) | undefined;
-    }>, {}, {}, {}, {
-        getFieldRowClasses(field: any): any;
-        fieldErrors(field: any): any;
-        fieldDisabled(field: any): any;
-        fieldReadonly(field: any): any;
-        fieldFeatured(field: any): any;
-        fieldRequired(field: any): any;
-    } & import("vue").MethodOptions, {}>;
-    errors: never[];
-    children: import("vue").Ref<never[], never[]>;
-    collapseStates: {};
-}, {
-    fields(): any[];
-    groups(): Group[];
-}, {
-    fieldVisible(field: any): any;
-    onFieldValidated(res: any, errors: any, field: any): void;
-    onRefreshModel(): void;
-    onModelUpdated(newVal: any, schema: any): void;
-    onPartialToggled(field: any, model: any): void;
-    validate(isAsync?: null): boolean | any[] | Promise<boolean | any[]>;
-    clearValidationErrors(): void;
-}, import("vue").DefineComponent<{}, {}, {}, {}, {
-    getFieldRowClasses(field: any): any;
-    fieldErrors(field: any): any;
-    fieldDisabled(field: any): any;
-    fieldReadonly(field: any): any;
-    fieldFeatured(field: any): any;
-    fieldRequired(field: any): any;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, import("vue").ComponentOptionsMixin, ("validated" | "modelUpdated" | "refreshModel" | "partialToggled" | "showNewPartialModal")[], "validated" | "modelUpdated" | "refreshModel" | "partialToggled" | "showNewPartialModal", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    schema: {
-        type: ObjectConstructor;
-        default: () => undefined;
-    };
-    model: {
-        type: ObjectConstructor;
-        default: () => undefined;
-    };
-    options: {
-        type: ObjectConstructor;
-        default(): {
-            validateAfterLoad: boolean;
-            validateAfterChanged: boolean;
-            child: import("vue").Ref<never[], never[]>;
-            fieldIdPrefix: string;
-            validateAsync: boolean;
-            validationErrorClass: string;
-            validationSuccessClass: string;
-            helpAsHtml: boolean;
-        };
-    };
-    multiple: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    isNewModel: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    tag: {
-        type: StringConstructor;
-        default: string;
-        validator: (value: unknown) => boolean;
-    };
-    enableRedisPartial: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    isEditing: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}>> & Readonly<{
-    onModelUpdated?: ((...args: any[]) => any) | undefined;
-    onRefreshModel?: ((...args: any[]) => any) | undefined;
-    onValidated?: ((...args: any[]) => any) | undefined;
-    onPartialToggled?: ((...args: any[]) => any) | undefined;
-    onShowNewPartialModal?: ((...args: any[]) => any) | undefined;
-}>, {
-    options: Record<string, any>;
-    model: Record<string, any>;
-    schema: Record<string, any>;
-    tag: string;
-    isEditing: boolean;
-    multiple: boolean;
-    isNewModel: boolean;
-    enableRedisPartial: boolean;
-}, {}, {
-    formGroup: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-        vfg: {
-            type: ObjectConstructor;
-            required: true;
-        };
-        model: {
-            type: ObjectConstructor;
-            default: () => undefined;
-        };
-        options: {
-            type: ObjectConstructor;
-            default: () => undefined;
-        };
-        field: {
-            type: ObjectConstructor;
-            required: true;
-        };
-        errors: {
-            type: ArrayConstructor;
-            default(): never[];
-        };
-    }>, {}, {
-        child: import("vue").Ref<any, any>;
-    }, {
-        schema(): Record<string, any>;
-    }, {
-        sanitize(str: any): string;
-        fieldTypeHasLabel(field: any): boolean;
-        getFieldID(schema: any): string;
-        getTooltipId(schema: any): string;
-        getFieldComponent(fieldSchema: any): any;
-        getButtonType(btn: any): any;
-        onFieldValidated(res: any, errors: any, field: any): void;
-        buttonVisibility(field: any): any;
-        buttonClickHandler(btn: any, field: any, event: any): any;
-        fieldHint(field: any): any;
-        fieldErrors(field: any): any[];
-        onRefreshModel(): void;
-        onModelUpdated(newVal: any, schema: any): void;
-        validate(calledParent: any): any;
-        clearValidationErrors(): any;
-        formattedLabel(originalLabel: any): any;
-    }, import("vue").DefineComponent<{}, {}, {}, {}, {
-        getFieldRowClasses(field: any): any;
-        fieldErrors(field: any): any;
-        fieldDisabled(field: any): any;
-        fieldReadonly(field: any): any;
-        fieldFeatured(field: any): any;
-        fieldRequired(field: any): any;
-    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, import("vue").ComponentOptionsMixin, ("validated" | "modelUpdated" | "refreshModel")[], "validated" | "modelUpdated" | "refreshModel", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-        vfg: {
-            type: ObjectConstructor;
-            required: true;
-        };
-        model: {
-            type: ObjectConstructor;
-            default: () => undefined;
-        };
-        options: {
-            type: ObjectConstructor;
-            default: () => undefined;
-        };
-        field: {
-            type: ObjectConstructor;
-            required: true;
-        };
-        errors: {
-            type: ArrayConstructor;
-            default(): never[];
-        };
-    }>> & Readonly<{
-        onModelUpdated?: ((...args: any[]) => any) | undefined;
-        onRefreshModel?: ((...args: any[]) => any) | undefined;
-        onValidated?: ((...args: any[]) => any) | undefined;
-    }>, {
-        options: Record<string, any>;
-        errors: unknown[];
-        model: Record<string, any>;
-    }, {}, typeof import("../utils/fieldsLoader"), {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-    formRedis: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-        tag: {
-            type: StringConstructor;
-            default: string;
-            validator: (value: string) => boolean;
-        };
-        model: {
-            type: ObjectConstructor;
-            default: () => undefined;
-        };
-        options: {
-            type: ObjectConstructor;
-            required: true;
-        };
-        field: {
-            type: import("vue").PropType<import("..").FormRedisFields>;
-            required: true;
-        };
-        vfg: {
-            type: ObjectConstructor;
-            required: true;
-        };
-        errors: {
-            type: ArrayConstructor;
-            default(): never[];
-        };
-        redisPath: {
-            type: StringConstructor;
-            default: undefined;
-            required: false;
-        };
-        isEditing: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-        validated: (res: boolean, errors: any[], field: any) => any;
-        modelUpdated: (payload: any, schema: string) => any;
-        refreshModel: () => any;
-        partialToggled: (field: string, model: Record<string, any>) => any;
-        showNewPartialModal: () => any;
-    }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-        tag: {
-            type: StringConstructor;
-            default: string;
-            validator: (value: string) => boolean;
-        };
-        model: {
-            type: ObjectConstructor;
-            default: () => undefined;
-        };
-        options: {
-            type: ObjectConstructor;
-            required: true;
-        };
-        field: {
-            type: import("vue").PropType<import("..").FormRedisFields>;
-            required: true;
-        };
-        vfg: {
-            type: ObjectConstructor;
-            required: true;
-        };
-        errors: {
-            type: ArrayConstructor;
-            default(): never[];
-        };
-        redisPath: {
-            type: StringConstructor;
-            default: undefined;
-            required: false;
-        };
-        isEditing: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-    }>> & Readonly<{
-        onValidated?: ((res: boolean, errors: any[], field: any) => any) | undefined;
-        onModelUpdated?: ((payload: any, schema: string) => any) | undefined;
-        onRefreshModel?: (() => any) | undefined;
-        onPartialToggled?: ((field: string, model: Record<string, any>) => any) | undefined;
-        onShowNewPartialModal?: (() => any) | undefined;
-    }>, {
-        errors: unknown[];
-        model: Record<string, any>;
-        tag: string;
-        redisPath: string;
-        isEditing: boolean;
-    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-}, {}, string, () => {
-    autofillSlot?: import("vue").Slot<any> | undefined;
-}, true, {}, any>;
-export default _default;
-export type FGCollapsibleOptions = import("../types/form-generator").FGCollapsibleOptions;
-export type FGSlots = import("../types/form-generator").FGSlots;
-export type PartialGroup = {
-    collapsible?: FGCollapsibleOptions | undefined;
-    slots?: FGSlots | undefined;
-};
-export type Group = Record<string, any> & PartialGroup;
-//# sourceMappingURL=FormGenerator.vue.d.ts.map

package/dist/types/components/FormGenerator.vue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FormGenerator.vue.d.ts","sourceRoot":"","sources":["../../../src/components/FormGenerator.vue"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCA2qBa,OAAO,yBAAyB,EAAE,oBAAoB;sBACtD,OAAO,yBAAyB,EAAE,OAAO;;kBAG5C,oBAAoB,YAAC;YACrB,OAAO,YAAC;;oBAEL,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,YAAY"}

package/dist/types/components/FormGroup.vue.d.ts

@@ -1,82 +0,0 @@
-declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    vfg: {
-        type: ObjectConstructor;
-        required: true;
-    };
-    model: {
-        type: ObjectConstructor;
-        default: () => undefined;
-    };
-    options: {
-        type: ObjectConstructor;
-        default: () => undefined;
-    };
-    field: {
-        type: ObjectConstructor;
-        required: true;
-    };
-    errors: {
-        type: ArrayConstructor;
-        default(): never[];
-    };
-}>, {}, {
-    child: import("vue").Ref<any, any>;
-}, {
-    schema(): Record<string, any>;
-}, {
-    sanitize(str: any): string;
-    fieldTypeHasLabel(field: any): boolean;
-    getFieldID(schema: any): string;
-    getTooltipId(schema: any): string;
-    getFieldComponent(fieldSchema: any): any;
-    getButtonType(btn: any): any;
-    onFieldValidated(res: any, errors: any, field: any): void;
-    buttonVisibility(field: any): any;
-    buttonClickHandler(btn: any, field: any, event: any): any;
-    fieldHint(field: any): any;
-    fieldErrors(field: any): any[];
-    onRefreshModel(): void;
-    onModelUpdated(newVal: any, schema: any): void;
-    validate(calledParent: any): any;
-    clearValidationErrors(): any;
-    formattedLabel(originalLabel: any): any;
-}, import("vue").DefineComponent<{}, {}, {}, {}, {
-    getFieldRowClasses(field: any): any;
-    fieldErrors(field: any): any;
-    fieldDisabled(field: any): any;
-    fieldReadonly(field: any): any;
-    fieldFeatured(field: any): any;
-    fieldRequired(field: any): any;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, import("vue").ComponentOptionsMixin, ("validated" | "modelUpdated" | "refreshModel")[], "validated" | "modelUpdated" | "refreshModel", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    vfg: {
-        type: ObjectConstructor;
-        required: true;
-    };
-    model: {
-        type: ObjectConstructor;
-        default: () => undefined;
-    };
-    options: {
-        type: ObjectConstructor;
-        default: () => undefined;
-    };
-    field: {
-        type: ObjectConstructor;
-        required: true;
-    };
-    errors: {
-        type: ArrayConstructor;
-        default(): never[];
-    };
-}>> & Readonly<{
-    onModelUpdated?: ((...args: any[]) => any) | undefined;
-    onRefreshModel?: ((...args: any[]) => any) | undefined;
-    onValidated?: ((...args: any[]) => any) | undefined;
-}>, {
-    options: Record<string, any>;
-    errors: unknown[];
-    model: Record<string, any>;
-}, {}, typeof fieldComponents, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-export default _default;
-import * as fieldComponents from '../utils/fieldsLoader';
-//# sourceMappingURL=FormGroup.vue.d.ts.map

package/dist/types/components/FormGroup.vue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FormGroup.vue.d.ts","sourceRoot":"","sources":["../../../src/components/FormGroup.vue"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCA8ViC,uBAAuB"}

package/dist/types/components/FormMixin.vue.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {
-    getFieldRowClasses(field: any): any;
-    fieldErrors(field: any): any;
-    fieldDisabled(field: any): any;
-    fieldReadonly(field: any): any;
-    fieldFeatured(field: any): any;
-    fieldRequired(field: any): any;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-export default _default;
-//# sourceMappingURL=FormMixin.vue.d.ts.map

package/dist/types/components/FormMixin.vue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FormMixin.vue.d.ts","sourceRoot":"","sources":["../../../src/components/FormMixin.vue"],"names":[],"mappings":""}

package/dist/types/components/FormRedis.vue.d.ts

@@ -1,99 +0,0 @@
-import { type PropType } from 'vue';
-import type { FormRedisFields } from '../types';
-declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    tag: {
-        type: StringConstructor;
-        default: string;
-        validator: (value: string) => boolean;
-    };
-    model: {
-        type: ObjectConstructor;
-        default: () => undefined;
-    };
-    options: {
-        type: ObjectConstructor;
-        required: true;
-    };
-    field: {
-        type: PropType<FormRedisFields>;
-        required: true;
-    };
-    vfg: {
-        type: ObjectConstructor;
-        required: true;
-    };
-    /**
-     * TODO: stronger type
-     */
-    errors: {
-        type: ArrayConstructor;
-        default(): never[];
-    };
-    redisPath: {
-        type: StringConstructor;
-        default: undefined;
-        required: false;
-    };
-    isEditing: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    validated: (res: boolean, errors: any[], field: any) => any;
-    modelUpdated: (payload: any, schema: string) => any;
-    refreshModel: () => any;
-    partialToggled: (field: string, model: Record<string, any>) => any;
-    showNewPartialModal: () => any;
-}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    tag: {
-        type: StringConstructor;
-        default: string;
-        validator: (value: string) => boolean;
-    };
-    model: {
-        type: ObjectConstructor;
-        default: () => undefined;
-    };
-    options: {
-        type: ObjectConstructor;
-        required: true;
-    };
-    field: {
-        type: PropType<FormRedisFields>;
-        required: true;
-    };
-    vfg: {
-        type: ObjectConstructor;
-        required: true;
-    };
-    /**
-     * TODO: stronger type
-     */
-    errors: {
-        type: ArrayConstructor;
-        default(): never[];
-    };
-    redisPath: {
-        type: StringConstructor;
-        default: undefined;
-        required: false;
-    };
-    isEditing: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}>> & Readonly<{
-    onValidated?: ((res: boolean, errors: any[], field: any) => any) | undefined;
-    onModelUpdated?: ((payload: any, schema: string) => any) | undefined;
-    onRefreshModel?: (() => any) | undefined;
-    onPartialToggled?: ((field: string, model: Record<string, any>) => any) | undefined;
-    onShowNewPartialModal?: (() => any) | undefined;
-}>, {
-    errors: unknown[];
-    model: Record<string, any>;
-    tag: string;
-    redisPath: string;
-    isEditing: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-export default _default;
-//# sourceMappingURL=FormRedis.vue.d.ts.map

package/dist/types/components/FormRedis.vue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FormRedis.vue.d.ts","sourceRoot":"","sources":["../../../src/components/FormRedis.vue"],"names":[],"mappings":"AAmQA,OAAO,EAAuC,KAAK,QAAQ,EAAE,MAAM,KAAK,CAAA;AAQxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;;;;;2BA2ehB,MAAM,KAAG,OAAO;;;;;;;;;;;cAa3B,QAAQ,CAAC,eAAe,CAAC;;;;;;;IAO3C;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;2BAtB0B,MAAM,KAAG,OAAO;;;;;;;;;;;cAa3B,QAAQ,CAAC,eAAe,CAAC;;;;;;;IAO3C;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;AAtCL,wBAuDG"}