@kong-ui-public/forms 4.20.2-pr.2701.377d8f5a8.0 → 4.20.3

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

@@ -0,0 +1,610 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    formModel: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    formSchema: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    formOptions: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    onModelUpdated: {
+        type: FunctionConstructor;
+        required: true;
+    };
+    onPartialToggled: {
+        type: FunctionConstructor;
+        required: true;
+    };
+    isEditing: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    enableRedisPartial: {
+        type: BooleanConstructor;
+        required: false;
+    };
+    showNewPartialModal: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+}>, {}, {
+    init: boolean;
+    authMethods: never[];
+    sessionManagement: boolean;
+    globalFields: null;
+    commonFieldsSchema: null;
+    authFieldsSchema: null;
+    openIdConnectLink: string;
+    openIdConnectJWKLink: string;
+    openIdConnectClusterNodesLink: string;
+    openIdConfigurationDocs: string;
+    openIdAuthorizationDocs: string;
+    advancedFieldsSchema: {
+        fields: never[];
+    };
+    advancedFields: null;
+    tabs: {
+        hash: string;
+        title: string;
+    }[];
+}, {
+    displayForm(): any;
+}, {
+    oidcSetup(): void;
+    getAuthMethodsValue(prop: any, evt: any): any[];
+    handleUpdate(evt: any, prop: any): void;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    formModel: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    formSchema: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    formOptions: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    onModelUpdated: {
+        type: FunctionConstructor;
+        required: true;
+    };
+    onPartialToggled: {
+        type: FunctionConstructor;
+        required: true;
+    };
+    isEditing: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    enableRedisPartial: {
+        type: BooleanConstructor;
+        required: false;
+    };
+    showNewPartialModal: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+}>> & Readonly<{}>, {
+    formOptions: Record<string, any>;
+    showNewPartialModal: Function;
+    enableRedisPartial: boolean;
+}, {}, {
+    VueFormGenerator: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        schema: {
+            type: ObjectConstructor;
+            default: () => undefined;
+        };
+        model: {
+            type: ObjectConstructor;
+            default: () => undefined;
+        };
+        options: {
+            type: ObjectConstructor;
+            default(): {
+                validateAfterLoad: boolean;
+                validateAfterChanged: boolean;
+                child: import("vue").Ref<never[], never[]>;
+                fieldIdPrefix: string;
+                validateAsync: boolean;
+                validationErrorClass: string;
+                validationSuccessClass: string;
+                helpAsHtml: boolean;
+            };
+        };
+        multiple: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        isNewModel: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        tag: {
+            type: StringConstructor;
+            default: string;
+            validator: (value: unknown) => boolean;
+        };
+        enableRedisPartial: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        isEditing: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {}, {
+        vfg: import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            schema: {
+                type: ObjectConstructor;
+                default: () => undefined;
+            };
+            model: {
+                type: ObjectConstructor;
+                default: () => undefined;
+            };
+            options: {
+                type: ObjectConstructor;
+                default(): {
+                    validateAfterLoad: boolean;
+                    validateAfterChanged: boolean;
+                    child: import("vue").Ref<never[], never[]>;
+                    fieldIdPrefix: string;
+                    validateAsync: boolean;
+                    validationErrorClass: string;
+                    validationSuccessClass: string;
+                    helpAsHtml: boolean;
+                };
+            };
+            multiple: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isNewModel: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            tag: {
+                type: StringConstructor;
+                default: string;
+                validator: (value: unknown) => boolean;
+            };
+            enableRedisPartial: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isEditing: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onModelUpdated?: ((...args: any[]) => any) | undefined;
+            onRefreshModel?: ((...args: any[]) => any) | undefined;
+            onValidated?: ((...args: any[]) => any) | undefined;
+            onPartialToggled?: ((...args: any[]) => any) | undefined;
+            onShowNewPartialModal?: ((...args: any[]) => any) | undefined;
+        }>, {}, {}, {}, import("vue").MethodOptions, import("vue").DefineComponent<{}, {}, {}, {}, {
+            getFieldRowClasses(field: any): {
+                [x: number]: any;
+                disabled: any;
+                readonly: any;
+                featured: any;
+                required: any;
+            };
+            fieldErrors(field: any): any;
+            fieldDisabled(field: any): any;
+            fieldReadonly(field: any): any;
+            fieldFeatured(field: any): any;
+            fieldRequired(field: any): any;
+        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, import("vue").ComponentOptionsMixin, {}, Readonly<import("vue").ExtractPropTypes<{
+            schema: {
+                type: ObjectConstructor;
+                default: () => undefined;
+            };
+            model: {
+                type: ObjectConstructor;
+                default: () => undefined;
+            };
+            options: {
+                type: ObjectConstructor;
+                default(): {
+                    validateAfterLoad: boolean;
+                    validateAfterChanged: boolean;
+                    child: import("vue").Ref<never[], never[]>;
+                    fieldIdPrefix: string;
+                    validateAsync: boolean;
+                    validationErrorClass: string;
+                    validationSuccessClass: string;
+                    helpAsHtml: boolean;
+                };
+            };
+            multiple: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isNewModel: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            tag: {
+                type: StringConstructor;
+                default: string;
+                validator: (value: unknown) => boolean;
+            };
+            enableRedisPartial: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isEditing: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onModelUpdated?: ((...args: any[]) => any) | undefined;
+            onRefreshModel?: ((...args: any[]) => any) | undefined;
+            onValidated?: ((...args: any[]) => any) | undefined;
+            onPartialToggled?: ((...args: any[]) => any) | undefined;
+            onShowNewPartialModal?: ((...args: any[]) => any) | undefined;
+        }>, {}, false, {}, {}, {}, {}, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: Readonly<{}> & Readonly<{}>;
+            B: {};
+            D: {};
+            C: {};
+            M: {
+                getFieldRowClasses(field: any): {
+                    [x: number]: any;
+                    disabled: any;
+                    readonly: any;
+                    featured: any;
+                    required: any;
+                };
+                fieldErrors(field: any): any;
+                fieldDisabled(field: any): any;
+                fieldReadonly(field: any): any;
+                fieldFeatured(field: any): any;
+                fieldRequired(field: any): any;
+            };
+            Defaults: {};
+        } & {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{}> & Readonly<{}> & Readonly<import("vue").ExtractPropTypes<{
+            schema: {
+                type: ObjectConstructor;
+                default: () => undefined;
+            };
+            model: {
+                type: ObjectConstructor;
+                default: () => undefined;
+            };
+            options: {
+                type: ObjectConstructor;
+                default(): {
+                    validateAfterLoad: boolean;
+                    validateAfterChanged: boolean;
+                    child: import("vue").Ref<never[], never[]>;
+                    fieldIdPrefix: string;
+                    validateAsync: boolean;
+                    validationErrorClass: string;
+                    validationSuccessClass: string;
+                    helpAsHtml: boolean;
+                };
+            };
+            multiple: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isNewModel: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            tag: {
+                type: StringConstructor;
+                default: string;
+                validator: (value: unknown) => boolean;
+            };
+            enableRedisPartial: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isEditing: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onModelUpdated?: ((...args: any[]) => any) | undefined;
+            onRefreshModel?: ((...args: any[]) => any) | undefined;
+            onValidated?: ((...args: any[]) => any) | undefined;
+            onPartialToggled?: ((...args: any[]) => any) | undefined;
+            onShowNewPartialModal?: ((...args: any[]) => any) | undefined;
+        }>, {}, {}, {}, {
+            getFieldRowClasses(field: any): {
+                [x: number]: any;
+                disabled: any;
+                readonly: any;
+                featured: any;
+                required: any;
+            };
+            fieldErrors(field: any): any;
+            fieldDisabled(field: any): any;
+            fieldReadonly(field: any): any;
+            fieldFeatured(field: any): any;
+            fieldRequired(field: any): any;
+        } & import("vue").MethodOptions, {}>;
+        errors: never[];
+        children: import("vue").Ref<never[], never[]>;
+        collapseStates: {};
+    }, {
+        fields(): any[];
+        groups(): import("../FormGenerator.vue").Group[];
+    }, {
+        fieldVisible(field: any): any;
+        onFieldValidated(res: any, errors: any, field: any): void;
+        onRefreshModel(): void;
+        onModelUpdated(newVal: any, schema: any): void;
+        onPartialToggled(field: any, model: any): void;
+        validate(isAsync?: null): boolean | any[] | Promise<boolean | any[]>;
+        clearValidationErrors(): void;
+    }, import("vue").DefineComponent<{}, {}, {}, {}, {
+        getFieldRowClasses(field: any): {
+            [x: number]: any;
+            disabled: any;
+            readonly: any;
+            featured: any;
+            required: any;
+        };
+        fieldErrors(field: any): any;
+        fieldDisabled(field: any): any;
+        fieldReadonly(field: any): any;
+        fieldFeatured(field: any): any;
+        fieldRequired(field: any): any;
+    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, import("vue").ComponentOptionsMixin, ("validated" | "modelUpdated" | "refreshModel" | "partialToggled" | "showNewPartialModal")[], "validated" | "modelUpdated" | "refreshModel" | "partialToggled" | "showNewPartialModal", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        schema: {
+            type: ObjectConstructor;
+            default: () => undefined;
+        };
+        model: {
+            type: ObjectConstructor;
+            default: () => undefined;
+        };
+        options: {
+            type: ObjectConstructor;
+            default(): {
+                validateAfterLoad: boolean;
+                validateAfterChanged: boolean;
+                child: import("vue").Ref<never[], never[]>;
+                fieldIdPrefix: string;
+                validateAsync: boolean;
+                validationErrorClass: string;
+                validationSuccessClass: string;
+                helpAsHtml: boolean;
+            };
+        };
+        multiple: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        isNewModel: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        tag: {
+            type: StringConstructor;
+            default: string;
+            validator: (value: unknown) => boolean;
+        };
+        enableRedisPartial: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        isEditing: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onModelUpdated?: ((...args: any[]) => any) | undefined;
+        onRefreshModel?: ((...args: any[]) => any) | undefined;
+        onValidated?: ((...args: any[]) => any) | undefined;
+        onPartialToggled?: ((...args: any[]) => any) | undefined;
+        onShowNewPartialModal?: ((...args: any[]) => any) | undefined;
+    }>, {
+        options: Record<string, any>;
+        model: Record<string, any>;
+        schema: Record<string, any>;
+        tag: string;
+        isEditing: boolean;
+        multiple: boolean;
+        isNewModel: boolean;
+        enableRedisPartial: boolean;
+    }, {}, {
+        formGroup: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            vfg: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            model: {
+                type: ObjectConstructor;
+                default: () => undefined;
+            };
+            options: {
+                type: ObjectConstructor;
+                default: () => undefined;
+            };
+            field: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            errors: {
+                type: ArrayConstructor;
+                default(): never[];
+            };
+        }>, {}, {
+            child: import("vue").Ref<any, any>;
+        }, {
+            schema(): Record<string, any>;
+        }, {
+            sanitize(str: any): string;
+            fieldTypeHasLabel(field: any): boolean;
+            getFieldID(schema: any): string;
+            getTooltipId(schema: any): string;
+            getFieldComponent(fieldSchema: any): any;
+            getButtonType(btn: any): any;
+            onFieldValidated(res: any, errors: any, field: any): void;
+            buttonVisibility(field: any): any;
+            buttonClickHandler(btn: any, field: any, event: any): any;
+            fieldHint(field: any): any;
+            fieldErrors(field: any): any[];
+            onRefreshModel(): void;
+            onModelUpdated(newVal: any, schema: any): void;
+            validate(calledParent: any): any;
+            clearValidationErrors(): any;
+            formattedLabel(originalLabel: any): any;
+        }, import("vue").DefineComponent<{}, {}, {}, {}, {
+            getFieldRowClasses(field: any): {
+                [x: number]: any;
+                disabled: any;
+                readonly: any;
+                featured: any;
+                required: any;
+            };
+            fieldErrors(field: any): any;
+            fieldDisabled(field: any): any;
+            fieldReadonly(field: any): any;
+            fieldFeatured(field: any): any;
+            fieldRequired(field: any): any;
+        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, import("vue").ComponentOptionsMixin, ("validated" | "modelUpdated" | "refreshModel")[], "validated" | "modelUpdated" | "refreshModel", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            vfg: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            model: {
+                type: ObjectConstructor;
+                default: () => undefined;
+            };
+            options: {
+                type: ObjectConstructor;
+                default: () => undefined;
+            };
+            field: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            errors: {
+                type: ArrayConstructor;
+                default(): never[];
+            };
+        }>> & Readonly<{
+            onModelUpdated?: ((...args: any[]) => any) | undefined;
+            onRefreshModel?: ((...args: any[]) => any) | undefined;
+            onValidated?: ((...args: any[]) => any) | undefined;
+        }>, {
+            options: Record<string, any>;
+            errors: unknown[];
+            model: Record<string, any>;
+        }, {}, typeof import("../../utils/fieldsLoader"), {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        formRedis: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            tag: {
+                type: StringConstructor;
+                default: string;
+                validator: (value: string) => boolean;
+            };
+            model: {
+                type: ObjectConstructor;
+                default: () => undefined;
+            };
+            options: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            field: {
+                type: import("vue").PropType<import("../..").FormRedisFields>;
+                required: true;
+            };
+            vfg: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            errors: {
+                type: ArrayConstructor;
+                default(): never[];
+            };
+            redisPath: {
+                type: StringConstructor;
+                default: undefined;
+                required: false;
+            };
+            isEditing: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+            validated: (res: boolean, errors: any[], field: any) => any;
+            modelUpdated: (payload: any, schema: string) => any;
+            refreshModel: () => any;
+            partialToggled: (field: string, model: Record<string, any>) => any;
+            showNewPartialModal: () => any;
+        }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            tag: {
+                type: StringConstructor;
+                default: string;
+                validator: (value: string) => boolean;
+            };
+            model: {
+                type: ObjectConstructor;
+                default: () => undefined;
+            };
+            options: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            field: {
+                type: import("vue").PropType<import("../..").FormRedisFields>;
+                required: true;
+            };
+            vfg: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            errors: {
+                type: ArrayConstructor;
+                default(): never[];
+            };
+            redisPath: {
+                type: StringConstructor;
+                default: undefined;
+                required: false;
+            };
+            isEditing: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onValidated?: ((res: boolean, errors: any[], field: any) => any) | undefined;
+            onModelUpdated?: ((payload: any, schema: string) => any) | undefined;
+            onRefreshModel?: (() => any) | undefined;
+            onPartialToggled?: ((field: string, model: Record<string, any>) => any) | undefined;
+            onShowNewPartialModal?: (() => any) | undefined;
+        }>, {
+            errors: unknown[];
+            model: Record<string, any>;
+            tag: string;
+            redisPath: string;
+            isEditing: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, () => {
+        autofillSlot?: import("vue").Slot<any> | undefined;
+    }, true, {}, any>;
+}, {}, string, () => {
+    autofillSlot: import("vue").Slot<any> | undefined;
+}, true, {}, any>;
+export default _default;
+//# sourceMappingURL=OIDCForm.vue.d.ts.map

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"PostFunction.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/forms/PostFunction.vue"],"names":[],"mappings":"AAyFA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAA;;;;;;;;;;;;;;;cAoKb,QAAQ,CAAC,MAAM,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;cAApB,QAAQ,CAAC,MAAM,IAAI,CAAC;;;;;;;;;;AAjB1C,wBAyBG"}

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

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

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

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