@kong-ui-public/forms 4.27.3-pr.3470.87bb970d7.0 → 4.27.3

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

@@ -0,0 +1,1638 @@
+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;
+    };
+    isKonnectManagedRedisEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showNewPartialModal: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+}>, {}, {
+    init: boolean;
+    authMethods: never[];
+    sessionManagement: boolean;
+    principalsMode: null;
+    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;
+    hasPrincipalsFields(): any;
+    isKonnect(): boolean;
+    useNewAuthMethodsField(): boolean;
+    authMethodItems(): {
+        label: any;
+        value: any;
+    }[];
+    selectedAuthMethods(): any[];
+}, {
+    oidcSetup(): void;
+    getAuthMethodsValue(prop: any, evt: any): any[];
+    handleUpdate(evt: any, prop: any): void;
+    handleAuthMethodsSelect(selectedValues: any): void;
+    handleSessionChange(value: any): void;
+    handlePrincipalsModeChange(mode: 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;
+    };
+    isKonnectManagedRedisEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showNewPartialModal: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+}>> & Readonly<{}>, {
+    formOptions: Record<string, any>;
+    isKonnectManagedRedisEnabled: boolean;
+    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;
+        };
+        isKonnectManagedRedisEnabled: {
+            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;
+            };
+            isKonnectManagedRedisEnabled: {
+                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;
+            };
+            isKonnectManagedRedisEnabled: {
+                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;
+            };
+            isKonnectManagedRedisEnabled: {
+                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;
+        };
+        isKonnectManagedRedisEnabled: {
+            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;
+        isKonnectManagedRedisEnabled: 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.ts"), {}, 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("../../index.ts").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;
+            };
+            isKonnectManagedRedisEnabled: {
+                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("../../index.ts").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;
+            };
+            isKonnectManagedRedisEnabled: {
+                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;
+            isKonnectManagedRedisEnabled: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, () => {
+        autofillSlot?: import("vue").Slot<any> | undefined;
+    }, true, {}, any>;
+    OIDCPrincipals: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        formModel: {
+            type: ObjectConstructor;
+            required: true;
+        };
+        formSchema: {
+            type: ObjectConstructor;
+            required: true;
+        };
+        formOptions: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        commonFieldsSchema: {
+            type: ObjectConstructor;
+            required: true;
+        };
+        onModelUpdated: {
+            type: FunctionConstructor;
+            required: true;
+        };
+        isEditing: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {}, {
+        MODE_KONG_IDENTITY: string;
+        MODE_EXTERNAL: string;
+        lookupMethodItems: {
+            label: string;
+            value: string;
+            description: string;
+        }[];
+        KUI_ICON_SIZE_20: "12px";
+        KUI_ICON_SIZE_30: "16px";
+        KUI_ICON_SIZE_40: "20px";
+        selectedMode: string;
+        selectedLookupMethod: string;
+        kongIdentityServers: never[];
+        kongIdentityServersLoading: boolean;
+        clients: never[];
+        clientsLoading: boolean;
+        selectedServer: null;
+        restoringServer: boolean;
+        leavePromptType: null;
+    }, {
+        issuerFieldsSchema(): {
+            fields: any;
+        };
+        externalClientIdField(): any;
+        externalClientSecretField(): any;
+        kongIdentityServerItems(): {
+            label: any;
+            value: any;
+        }[];
+        clientItems(): {
+            label: any;
+            value: any;
+        }[];
+        clientIdArray(): any[];
+        clientSecretArray(): any[];
+        isRemoveClientDisabled(): true;
+    }, {
+        fetchKongIdentityServers(): Promise<void>;
+        fetchClients(serverId: any): Promise<void>;
+        handleServerChange(serverId: any): void;
+        handleClientChange(index: any, clientId: any): void;
+        addClientRow(): void;
+        removeClientRow(index: any): void;
+        handleClientSecretChange(index: any, value: any): void;
+        getClientItemsForRow(index: any): {
+            disabled: boolean;
+            label: any;
+            value: any;
+        }[];
+        getIdentifierClaimInputValue(): any;
+        handleIdentifierClaimChange(rawValue: any): void;
+        handleMatchConsumerChange(checked: any): void;
+        handleLookupMethodChange(value: any): void;
+        updateField(field: any, value: any): void;
+        handleLeaveConfirmed(): void;
+        handleModeChange(newMode: any): void;
+    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "mode-change"[], "mode-change", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        formModel: {
+            type: ObjectConstructor;
+            required: true;
+        };
+        formSchema: {
+            type: ObjectConstructor;
+            required: true;
+        };
+        formOptions: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        commonFieldsSchema: {
+            type: ObjectConstructor;
+            required: true;
+        };
+        onModelUpdated: {
+            type: FunctionConstructor;
+            required: true;
+        };
+        isEditing: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        "onMode-change"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        formOptions: Record<string, any>;
+        isEditing: 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;
+            };
+            isKonnectManagedRedisEnabled: {
+                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;
+                };
+                isKonnectManagedRedisEnabled: {
+                    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;
+                };
+                isKonnectManagedRedisEnabled: {
+                    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;
+                };
+                isKonnectManagedRedisEnabled: {
+                    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;
+            };
+            isKonnectManagedRedisEnabled: {
+                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;
+            isKonnectManagedRedisEnabled: 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.ts"), {}, 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("../../index.ts").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;
+                };
+                isKonnectManagedRedisEnabled: {
+                    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("../../index.ts").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;
+                };
+                isKonnectManagedRedisEnabled: {
+                    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;
+                isKonnectManagedRedisEnabled: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, () => {
+            autofillSlot?: import("vue").Slot<any> | undefined;
+        }, true, {}, any>;
+        AddIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            color: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            display: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            decorative: {
+                type: BooleanConstructor;
+                required: false;
+                default: boolean;
+            };
+            size: {
+                type: (StringConstructor | NumberConstructor)[];
+                required: false;
+                default: "24px";
+                validator: (sizeValue: number | string) => boolean;
+            };
+            as: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            staticIds: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            color: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            display: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            decorative: {
+                type: BooleanConstructor;
+                required: false;
+                default: boolean;
+            };
+            size: {
+                type: (StringConstructor | NumberConstructor)[];
+                required: false;
+                default: "24px";
+                validator: (sizeValue: number | string) => boolean;
+            };
+            as: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            staticIds: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            title: string;
+            color: string;
+            display: string;
+            decorative: boolean;
+            size: string | number;
+            as: string;
+            staticIds: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        CloseIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            color: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            display: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            decorative: {
+                type: BooleanConstructor;
+                required: false;
+                default: boolean;
+            };
+            size: {
+                type: (StringConstructor | NumberConstructor)[];
+                required: false;
+                default: "24px";
+                validator: (sizeValue: number | string) => boolean;
+            };
+            as: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            staticIds: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            color: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            display: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            decorative: {
+                type: BooleanConstructor;
+                required: false;
+                default: boolean;
+            };
+            size: {
+                type: (StringConstructor | NumberConstructor)[];
+                required: false;
+                default: "24px";
+                validator: (sizeValue: number | string) => boolean;
+            };
+            as: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            staticIds: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            title: string;
+            color: string;
+            display: string;
+            decorative: boolean;
+            size: string | number;
+            as: string;
+            staticIds: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        KeyIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            color: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            display: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            decorative: {
+                type: BooleanConstructor;
+                required: false;
+                default: boolean;
+            };
+            size: {
+                type: (StringConstructor | NumberConstructor)[];
+                required: false;
+                default: "24px";
+                validator: (sizeValue: number | string) => boolean;
+            };
+            as: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            staticIds: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            color: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            display: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            decorative: {
+                type: BooleanConstructor;
+                required: false;
+                default: boolean;
+            };
+            size: {
+                type: (StringConstructor | NumberConstructor)[];
+                required: false;
+                default: "24px";
+                validator: (sizeValue: number | string) => boolean;
+            };
+            as: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            staticIds: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            title: string;
+            color: string;
+            display: string;
+            decorative: boolean;
+            size: string | number;
+            as: string;
+            staticIds: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        WorldIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            color: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            display: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            decorative: {
+                type: BooleanConstructor;
+                required: false;
+                default: boolean;
+            };
+            size: {
+                type: (StringConstructor | NumberConstructor)[];
+                required: false;
+                default: "24px";
+                validator: (sizeValue: number | string) => boolean;
+            };
+            as: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            staticIds: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            color: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            display: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            decorative: {
+                type: BooleanConstructor;
+                required: false;
+                default: boolean;
+            };
+            size: {
+                type: (StringConstructor | NumberConstructor)[];
+                required: false;
+                default: "24px";
+                validator: (sizeValue: number | string) => boolean;
+            };
+            as: {
+                type: StringConstructor;
+                required: false;
+                default: string;
+            };
+            staticIds: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            title: string;
+            color: string;
+            display: string;
+            decorative: boolean;
+            size: string | number;
+            as: string;
+            staticIds: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, () => {
+    autofillSlot: import("vue").Slot<any> | undefined;
+}, true, {}, any>;
+//# sourceMappingURL=OIDCForm.vue.d.ts.map