@kong-ui-public/forms 4.35.1-pr.3869.e876c8c8a.0 → 4.35.1

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

@@ -0,0 +1,1939 @@
+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;
+    };
+    /**
+     * Identity Principals UI feature flag (khcp-20393). When false, behave as if the
+     * `principals` fields aren't in the schema — the Kong Identity principals section is
+     * hidden and the legacy common-fields form renders instead.
+     */
+    identityPrincipalsUiEnabled: {
+        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, ("click:learn-more" | "click:create-entity")[], "click:learn-more" | "click:create-entity", 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;
+    };
+    /**
+     * Identity Principals UI feature flag (khcp-20393). When false, behave as if the
+     * `principals` fields aren't in the schema — the Kong Identity principals section is
+     * hidden and the legacy common-fields form renders instead.
+     */
+    identityPrincipalsUiEnabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showNewPartialModal: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+}>> & Readonly<{
+    "onClick:learn-more"?: ((...args: any[]) => any) | undefined;
+    "onClick:create-entity"?: ((...args: any[]) => any) | undefined;
+}>, {
+    formOptions: Record<string, any>;
+    isKonnectManagedRedisEnabled: boolean;
+    showNewPartialModal: Function;
+    enableRedisPartial: boolean;
+    identityPrincipalsUiEnabled: 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;
+        KUI_ICON_SIZE_20: "12px";
+        KUI_ICON_SIZE_30: "16px";
+        KUI_ICON_SIZE_40: "20px";
+        selectedMode: 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(): boolean;
+        isKonnect(): boolean;
+        hasAuthServersAccess(): boolean;
+        canCreateAuthServer(): boolean;
+        canCreateAuthServerClient(): boolean;
+        hasIncompatibleDataPlane(): any;
+        principalsEnabled(): boolean;
+        principalsGuideVisible(): boolean;
+        principalsSkeletonVisible(): boolean;
+    }, {
+        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;
+        }[];
+        updateField(field: any, value: any): void;
+        sanitize(str: any): string;
+        handleUsePrincipalLookupChange(enabled: any): void;
+        handleLeaveConfirmed(): void;
+        handleModeChange(newMode: any): void;
+    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("mode-change" | "click:learn-more" | "click:create-entity")[], "mode-change" | "click:learn-more" | "click:create-entity", 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;
+        "onClick:learn-more"?: ((...args: any[]) => any) | undefined;
+        "onClick:create-entity"?: ((...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>;
+        PrincipalLookupSettings: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            formModel: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            onModelUpdated: {
+                type: FunctionConstructor;
+                required: true;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            showEnableToggle: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            onEnabledChange: {
+                type: FunctionConstructor;
+                default: undefined;
+            };
+            dataPlaneIncompatible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            showPrincipalsFields: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isEditing: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {}, {
+            lookupMethodItems: {
+                label: string;
+                value: string;
+                description: string;
+            }[];
+            selectedLookupMethod: string;
+        }, {
+            lookupEnabled(): boolean;
+            fieldsDisabled(): boolean;
+            tokenClaimHelp(): "The token claim whose value is matched against the Custom identity name. Defaults to the subject (sub) claim, but you can specify a different claim if needed. Use dot notation for nested claims (for example, workload.id); escape literal periods with \\ (for example, workload\\.id)." | "Defaults to the subject (sub) claim, but you can specify a different token claim if needed. Use dot notation for nested claims (for example, workload.id); escape literal periods with \\ (for example, workload\\.id).";
+        }, {
+            handleEnableToggle(enabled: any): void;
+            getTokenClaimInputValue(): string;
+            handleTokenClaimChange(rawValue: any): void;
+            handleMatchConsumerChange(checked: any): void;
+            handleLookupMethodChange(value: any): void;
+            updateField(field: any, value: any): void;
+        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            formModel: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            onModelUpdated: {
+                type: FunctionConstructor;
+                required: true;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            showEnableToggle: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            onEnabledChange: {
+                type: FunctionConstructor;
+                default: undefined;
+            };
+            dataPlaneIncompatible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            showPrincipalsFields: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isEditing: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            disabled: boolean;
+            isEditing: boolean;
+            showEnableToggle: boolean;
+            onEnabledChange: Function;
+            dataPlaneIncompatible: boolean;
+            showPrincipalsFields: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        SecretInput: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+                autocomplete?: string;
+                showLabel?: string;
+                hideLabel?: string;
+                showMaskToggle?: boolean;
+            } & {
+                modelValue?: string;
+                masked?: boolean;
+            }> & Readonly<{
+                "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                "onUpdate:masked"?: ((value: boolean) => any) | undefined;
+            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                "update:modelValue": (value: string) => any;
+                "update:masked": (value: boolean) => any;
+            }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<{
+                autocomplete?: string;
+                showLabel?: string;
+                hideLabel?: string;
+                showMaskToggle?: boolean;
+            } & {
+                modelValue?: string;
+                masked?: boolean;
+            }> & Readonly<{
+                "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                "onUpdate:masked"?: ((value: boolean) => any) | undefined;
+            }>, {}, {}, {}, {}, {}>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<{
+            autocomplete?: string;
+            showLabel?: string;
+            hideLabel?: string;
+            showMaskToggle?: boolean;
+        } & {
+            modelValue?: string;
+            masked?: boolean;
+        }> & Readonly<{
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            "onUpdate:masked"?: ((value: boolean) => any) | undefined;
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (value: string) => any;
+            "update:masked": (value: boolean) => any;
+        }, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                [x: string]: ((props: any) => any) | undefined;
+            } & {
+                after?: (props: {
+                    masked: boolean;
+                    toggle: () => void;
+                }) => 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>;
+        BookIcon: 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>;
+    OIDCAuthMethods: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        authMethodItems: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        selectedAuthMethods: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        sessionManagement: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        principalsMode: {
+            type: StringConstructor;
+            default: null;
+        };
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("select" | "session-change")[], "select" | "session-change", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        authMethodItems: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        selectedAuthMethods: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        sessionManagement: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        principalsMode: {
+            type: StringConstructor;
+            default: null;
+        };
+    }>> & Readonly<{
+        onSelect?: ((...args: any[]) => any) | undefined;
+        "onSession-change"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        authMethodItems: unknown[];
+        selectedAuthMethods: unknown[];
+        sessionManagement: boolean;
+        principalsMode: string;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, () => {
+    autofillSlot: import("vue").Slot<any> | undefined;
+}, true, {}, any>;
+//# sourceMappingURL=OIDCForm.vue.d.ts.map