@kong-ui-public/forms 4.20.27 → 4.20.28-pr.2823.f13c2b2c0.0

package/dist/types/components/forms/OIDCForm.vue.d.ts

@@ -1,611 +0,0 @@
-declare const _default: typeof __VLS_export;
-export default _default;
-declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    formModel: {
-        type: ObjectConstructor;
-        required: true;
-    };
-    formSchema: {
-        type: ObjectConstructor;
-        required: true;
-    };
-    formOptions: {
-        type: ObjectConstructor;
-        default: () => void;
-    };
-    onModelUpdated: {
-        type: FunctionConstructor;
-        required: true;
-    };
-    onPartialToggled: {
-        type: FunctionConstructor;
-        required: true;
-    };
-    isEditing: {
-        type: BooleanConstructor;
-        required: true;
-    };
-    enableRedisPartial: {
-        type: BooleanConstructor;
-        required: false;
-    };
-    showNewPartialModal: {
-        type: FunctionConstructor;
-        default: () => void;
-    };
-}>, {}, {
-    init: boolean;
-    authMethods: never[];
-    sessionManagement: boolean;
-    globalFields: null;
-    commonFieldsSchema: null;
-    authFieldsSchema: null;
-    openIdConnectLink: string;
-    openIdConnectJWKLink: string;
-    openIdConnectClusterNodesLink: string;
-    openIdConfigurationDocs: string;
-    openIdAuthorizationDocs: string;
-    advancedFieldsSchema: {
-        fields: never[];
-    };
-    advancedFields: null;
-    tabs: {
-        hash: string;
-        title: string;
-    }[];
-}, {
-    displayForm(): any;
-}, {
-    oidcSetup(): void;
-    getAuthMethodsValue(prop: any, evt: any): any[];
-    handleUpdate(evt: any, prop: any): void;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    formModel: {
-        type: ObjectConstructor;
-        required: true;
-    };
-    formSchema: {
-        type: ObjectConstructor;
-        required: true;
-    };
-    formOptions: {
-        type: ObjectConstructor;
-        default: () => void;
-    };
-    onModelUpdated: {
-        type: FunctionConstructor;
-        required: true;
-    };
-    onPartialToggled: {
-        type: FunctionConstructor;
-        required: true;
-    };
-    isEditing: {
-        type: BooleanConstructor;
-        required: true;
-    };
-    enableRedisPartial: {
-        type: BooleanConstructor;
-        required: false;
-    };
-    showNewPartialModal: {
-        type: FunctionConstructor;
-        default: () => void;
-    };
-}>> & Readonly<{}>, {
-    formOptions: Record<string, any>;
-    showNewPartialModal: Function;
-    enableRedisPartial: boolean;
-}, {}, {
-    VueFormGenerator: 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): {
-                [x: number]: any;
-                disabled: any;
-                readonly: any;
-                featured: any;
-                required: 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): {
-                    [x: number]: any;
-                    disabled: any;
-                    readonly: any;
-                    featured: any;
-                    required: 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): {
-                [x: number]: any;
-                disabled: any;
-                readonly: any;
-                featured: any;
-                required: 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(): import("../FormGenerator.vue").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): {
-            [x: number]: any;
-            disabled: any;
-            readonly: any;
-            featured: any;
-            required: 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): {
-                [x: number]: any;
-                disabled: any;
-                readonly: any;
-                featured: any;
-                required: 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>;
-}, {}, string, () => {
-    autofillSlot: import("vue").Slot<any> | undefined;
-}, true, {}, any>;
-//# sourceMappingURL=OIDCForm.vue.d.ts.map

package/dist/types/components/forms/OIDCForm.vue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"OIDCForm.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/forms/OIDCForm.vue"],"names":[],"mappings":"wBA2gBqB,OAAO,YAAY;;AAqVxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4QG"}

package/dist/types/components/forms/PostFunction.vue.d.ts

@@ -1,49 +0,0 @@
-import type { PropType } from 'vue';
-declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    formModel: {
-        type: ObjectConstructor;
-        required: true;
-    };
-    formSchema: {
-        type: ObjectConstructor;
-        required: true;
-    };
-    formOptions: {
-        type: ObjectConstructor;
-        default: () => void;
-    };
-    onModelUpdated: {
-        type: PropType<() => void>;
-        required: true;
-    };
-    isEditing: {
-        type: BooleanConstructor;
-        required: true;
-    };
-}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    formModel: {
-        type: ObjectConstructor;
-        required: true;
-    };
-    formSchema: {
-        type: ObjectConstructor;
-        required: true;
-    };
-    formOptions: {
-        type: ObjectConstructor;
-        default: () => void;
-    };
-    onModelUpdated: {
-        type: PropType<() => void>;
-        required: true;
-    };
-    isEditing: {
-        type: BooleanConstructor;
-        required: true;
-    };
-}>> & Readonly<{}>, {
-    formOptions: Record<string, any>;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;
-//# sourceMappingURL=PostFunction.vue.d.ts.map

package/dist/types/components/forms/PostFunction.vue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PostFunction.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/forms/PostFunction.vue"],"names":[],"mappings":"AA0FA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAA;AA+GnC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;cAeI,QAAQ,CAAC,MAAM,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;cAApB,QAAQ,CAAC,MAAM,IAAI,CAAC;;;;;;;;;4EAQxC,CAAC;wBACkB,OAAO,YAAY;AAAxC,wBAAyC"}

package/dist/types/components/forms/RLAForm.vue.d.ts

@@ -1,14 +0,0 @@
-type __VLS_Props = {
-    formSchema: any;
-    formModel: Record<string, any>;
-    formOptions: any;
-    onModelUpdated: (value: any, model: string) => void;
-    onPartialToggled: (field: string, model: any) => void;
-    showNewPartialModal: (redisType: string) => void;
-    isEditing?: boolean;
-    enableRedisPartial?: boolean;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;
-//# sourceMappingURL=RLAForm.vue.d.ts.map

package/dist/types/components/forms/RLAForm.vue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RLAForm.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/forms/RLAForm.vue"],"names":[],"mappings":"AA4vBA,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,GAAG,CAAA;IACf,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC9B,WAAW,EAAE,GAAG,CAAA;IAChB,cAAc,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACnD,gBAAgB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAA;IACrD,mBAAmB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAA;IAChD,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B,CAAC;AAw2BF,QAAA,MAAM,YAAY,kSAEhB,CAAC;wBACkB,OAAO,YAAY;AAAxC,wBAAyC"}