@authup/client-web-kit/dist/components/entities/policy/APolicyForm.vue.d.ts

This package contains vue components.

import type { PropType } from 'vue';
import type { Policy } from '@authup/core-kit';
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    entity: {
        type: PropType<Policy>;
    };
    type: {
        type: PropType<string>;
    };
}>, {
    typeComputed: import("vue").ComputedRef<string>;
    typeComponents: Record<string, any>;
    data: import("vue").Ref<Policy, Policy>;
    busy: import("vue").Ref<boolean, boolean>;
    isEditing: import("vue").ComputedRef<boolean>;
    submit: () => Promise<void>;
    vuelidate: import("vue").Ref<import("@vuelidate/core").Validation<import("@vuelidate/core").ValidationArgs<unknown>, unknown>, import("@vuelidate/core").Validation<import("@vuelidate/core").ValidationArgs<unknown>, unknown>>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    entity: {
        type: PropType<Policy>;
    };
    type: {
        type: PropType<string>;
    };
}>> & Readonly<{}>, {}, {}, {
    AFormSubmit: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        isBusy: {
            type: BooleanConstructor;
            default: boolean;
        };
        isEditing: {
            type: BooleanConstructor;
            default: boolean;
        };
        isInvalid: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>, () => import("vue").VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "submit"[], "submit", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        isBusy: {
            type: BooleanConstructor;
            default: boolean;
        };
        isEditing: {
            type: BooleanConstructor;
            default: boolean;
        };
        isInvalid: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{
        onSubmit?: (...args: any[]) => any;
    }>, {
        isEditing: boolean;
        isBusy: boolean;
        isInvalid: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    APolicyTypePicker: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        type: {
            type: StringConstructor;
        };
        types: {
            type: PropType<(import("@vuecs/form-controls").FormSelectOption | string)[]>;
        };
    }>, {
        option: import("vue").Ref<string, string>;
        options: import("vue").ComputedRef<import("@vuecs/form-controls").FormSelectOption[]>;
        pick: (val: string) => void;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "pick"[], "pick", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        type: {
            type: StringConstructor;
        };
        types: {
            type: PropType<(import("@vuecs/form-controls").FormSelectOption | string)[]>;
        };
    }>> & Readonly<{
        onPick?: (...args: any[]) => any;
    }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    APolicyBasicForm: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        entity: {
            type: PropType<Policy>;
        };
    }>, {
        isEditing: import("vue").ComputedRef<boolean>;
        realmId: import("vue").ComputedRef<string>;
        handleUpdated: () => void;
        typeOptions: import("@vuecs/form-controls").FormSelectOption[];
        vuelidate: import("vue").Ref<import("@vuelidate/core").Validation<{
            name: {
                required: import("@vuelidate/core").ValidationRuleWithoutParams<any>;
                minLength: import("@vuelidate/core").ValidationRuleWithParams<{
                    min: number;
                }, any>;
                maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
                    max: number;
                }, any>;
            };
            invert: {};
            display_name: {
                minLength: import("@vuelidate/core").ValidationRuleWithParams<{
                    min: number;
                }, any>;
                maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
                    max: number;
                }, any>;
            };
            description: {
                minLength: import("@vuelidate/core").ValidationRuleWithParams<{
                    min: number;
                }, any>;
                maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
                    max: number;
                }, any>;
            };
            realm_id: {};
        }, {
            name: string;
            invert: boolean;
            display_name: string;
            description: string;
            realm_id: string;
        }>, import("@vuelidate/core").Validation<{
            name: {
                required: import("@vuelidate/core").ValidationRuleWithoutParams<any>;
                minLength: import("@vuelidate/core").ValidationRuleWithParams<{
                    min: number;
                }, any>;
                maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
                    max: number;
                }, any>;
            };
            invert: {};
            display_name: {
                minLength: import("@vuelidate/core").ValidationRuleWithParams<{
                    min: number;
                }, any>;
                maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
                    max: number;
                }, any>;
            };
            description: {
                minLength: import("@vuelidate/core").ValidationRuleWithParams<{
                    min: number;
                }, any>;
                maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
                    max: number;
                }, any>;
            };
            realm_id: {};
        }, {
            name: string;
            invert: boolean;
            display_name: string;
            description: string;
            realm_id: string;
        }>>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "updated"[], "updated", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        entity: {
            type: PropType<Policy>;
        };
    }>> & Readonly<{
        onUpdated?: (...args: any[]) => any;
    }>, {}, {}, {
        ARealmPicker: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            query: {
                type: PropType<import("rapiq").BuildInput<import("@authup/core-kit").Realm>>;
                default(): {};
            };
            realmId: {
                type: StringConstructor;
                default: any;
            };
            loadOnSetup: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: PropType<boolean | import("../../index.ts").ListLoadingOptions<import("@authup/core-kit").Realm>>;
                default: boolean;
            };
            noMore: {
                type: PropType<boolean | import("../../index.ts").ListNoMoreOptions<import("@authup/core-kit").Realm>>;
                default: boolean;
            };
            footer: {
                type: PropType<boolean | import("../../index.ts").ListFooterOptions<import("@authup/core-kit").Realm>>;
                default: boolean;
            };
            header: {
                type: PropType<boolean | import("../../index.ts").ListHeaderOptions<import("@authup/core-kit").Realm>>;
                default: boolean;
            };
            body: {
                type: PropType<import("../../index.ts").ListBodyOptions<import("@authup/core-kit").Realm>>;
            };
            value: {
                type: PropType<string[] | string | null>;
            };
            multiple: {
                type: PropType<boolean | undefined>;
            };
        }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            change: (values: string[]) => true;
        } & import("../../index.ts").EntityCollectionVEmitOptions<import("@authup/core-kit").Realm>, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            query: {
                type: PropType<import("rapiq").BuildInput<import("@authup/core-kit").Realm>>;
                default(): {};
            };
            realmId: {
                type: StringConstructor;
                default: any;
            };
            loadOnSetup: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: PropType<boolean | import("../../index.ts").ListLoadingOptions<import("@authup/core-kit").Realm>>;
                default: boolean;
            };
            noMore: {
                type: PropType<boolean | import("../../index.ts").ListNoMoreOptions<import("@authup/core-kit").Realm>>;
                default: boolean;
            };
            footer: {
                type: PropType<boolean | import("../../index.ts").ListFooterOptions<import("@authup/core-kit").Realm>>;
                default: boolean;
            };
            header: {
                type: PropType<boolean | import("../../index.ts").ListHeaderOptions<import("@authup/core-kit").Realm>>;
                default: boolean;
            };
            body: {
                type: PropType<import("../../index.ts").ListBodyOptions<import("@authup/core-kit").Realm>>;
            };
            value: {
                type: PropType<string[] | string | null>;
            };
            multiple: {
                type: PropType<boolean | undefined>;
            };
        }>> & Readonly<{
            onUpdated?: (item: import("@authup/core-kit").Realm) => any;
            onDeleted?: (item: import("@authup/core-kit").Realm) => any;
            onCreated?: (item: import("@authup/core-kit").Realm) => any;
            onChange?: (values: string[]) => any;
        }>, {
            footer: boolean;
            header: boolean;
            query: import("rapiq").BuildInput<import("@authup/core-kit").Realm>;
            realmId: string;
            loadOnSetup: boolean;
            loading: boolean;
            noMore: boolean;
        }, import("vue").SlotsType<import("../../index.ts").EntityPickerVSlots<import("@authup/core-kit").Realm>>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        VCFormInput: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            modelValue: {
                type: StringConstructor;
                default: string;
            };
            type: {
                type: StringConstructor;
                default: string;
            };
            groupAppendClass: {
                type: StringConstructor;
            };
            groupPrependClass: {
                type: StringConstructor;
            };
        }>, () => import("vue").VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            modelValue: {
                type: StringConstructor;
                default: string;
            };
            type: {
                type: StringConstructor;
                default: string;
            };
            groupAppendClass: {
                type: StringConstructor;
            };
            groupPrependClass: {
                type: StringConstructor;
            };
        }>> & Readonly<{
            "onUpdate:modelValue"?: (...args: any[]) => any;
        }>, {
            type: string;
            modelValue: string;
        }, import("vue").SlotsType<{
            groupAppend: {
                class: string;
                tag: string;
            };
            groupPrepend: {
                class: string;
                tag: string;
            };
        }>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        VCFormInputCheckbox: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            modelValue: {
                type: PropType<unknown | unknown[]>;
            };
            group: {
                type: BooleanConstructor;
            };
            groupClass: {
                type: StringConstructor;
            };
            label: {
                type: BooleanConstructor;
            };
            labelClass: {
                type: StringConstructor;
            };
            labelContent: {
                type: StringConstructor;
            };
        }>, () => import("vue").VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            modelValue: {
                type: PropType<unknown | unknown[]>;
            };
            group: {
                type: BooleanConstructor;
            };
            groupClass: {
                type: StringConstructor;
            };
            label: {
                type: BooleanConstructor;
            };
            labelClass: {
                type: StringConstructor;
            };
            labelContent: {
                type: StringConstructor;
            };
        }>> & Readonly<{
            "onUpdate:modelValue"?: (...args: any[]) => any;
        }>, {
            label: boolean;
            group: boolean;
        }, import("vue").SlotsType<{
            label: import("@vuecs/form-controls").FormInputCheckboxLabelSlotProps;
        }>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        VCFormGroup: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            label: {
                type: BooleanConstructor;
                default: any;
            };
            labelClass: {
                type: StringConstructor;
            };
            labelContent: {
                type: StringConstructor;
            };
            hint: {
                type: BooleanConstructor;
                default: any;
            };
            hintClass: {
                type: StringConstructor;
            };
            hintContent: {
                type: StringConstructor;
            };
            validation: {
                type: BooleanConstructor;
                default: any;
            };
            validationSeverity: {
                type: PropType<`${import("@vuecs/form-controls").ValidationSeverity}` | undefined>;
                default: any;
            };
            validationMessages: {
                type: PropType<import("@vuecs/form-controls").ValidationMessages>;
                default: any;
            };
        }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            label: {
                type: BooleanConstructor;
                default: any;
            };
            labelClass: {
                type: StringConstructor;
            };
            labelContent: {
                type: StringConstructor;
            };
            hint: {
                type: BooleanConstructor;
                default: any;
            };
            hintClass: {
                type: StringConstructor;
            };
            hintContent: {
                type: StringConstructor;
            };
            validation: {
                type: BooleanConstructor;
                default: any;
            };
            validationSeverity: {
                type: PropType<`${import("@vuecs/form-controls").ValidationSeverity}` | undefined>;
                default: any;
            };
            validationMessages: {
                type: PropType<import("@vuecs/form-controls").ValidationMessages>;
                default: any;
            };
        }>> & Readonly<{}>, {
            label: boolean;
            hint: boolean;
            validation: boolean;
            validationMessages: import("@vuecs/form-controls").ValidationMessages;
            validationSeverity: "error" | "warning";
        }, import("vue").SlotsType<{
            default: undefined;
            label: undefined;
            hint: undefined;
        }>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        IVuelidate: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            validation: {
                type: PropType<Record<string, any>>;
                required: true;
            };
        }>, () => import("vue").VNodeArrayChildren, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            validation: {
                type: PropType<Record<string, any>>;
                required: true;
            };
        }>> & Readonly<{}>, {}, import("vue").SlotsType<{
            default: import("@ilingo/vuelidate").SlotProps;
        }>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
//# sourceMappingURL=APolicyForm.vue.d.ts.map