@authup/client-web-kit 1.0.0-beta.24 → 1.0.0-beta.25

package/dist/components/entities/policy/APolicyForm.vue.d.ts

@@ -0,0 +1,445 @@
+import type { PropType } from 'vue';
+import type { Policy } from '@authup/core-kit';
+declare const _default: 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;
+    }>, {
+        isBusy: boolean;
+        isEditing: 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("../..").ListLoadingOptions<import("@authup/core-kit").Realm>>;
+                default: boolean;
+            };
+            noMore: {
+                type: PropType<boolean | import("../..").ListNoMoreOptions<import("@authup/core-kit").Realm>>;
+                default: boolean;
+            };
+            footer: {
+                type: PropType<boolean | import("../..").ListFooterOptions<import("@authup/core-kit").Realm>>;
+                default: boolean;
+            };
+            header: {
+                type: PropType<boolean | import("../..").ListHeaderOptions<import("@authup/core-kit").Realm>>;
+                default: boolean;
+            };
+            body: {
+                type: PropType<import("../..").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("../..").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("../..").ListLoadingOptions<import("@authup/core-kit").Realm>>;
+                default: boolean;
+            };
+            noMore: {
+                type: PropType<boolean | import("../..").ListNoMoreOptions<import("@authup/core-kit").Realm>>;
+                default: boolean;
+            };
+            footer: {
+                type: PropType<boolean | import("../..").ListFooterOptions<import("@authup/core-kit").Realm>>;
+                default: boolean;
+            };
+            header: {
+                type: PropType<boolean | import("../..").ListHeaderOptions<import("@authup/core-kit").Realm>>;
+                default: boolean;
+            };
+            body: {
+                type: PropType<import("../..").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("../..").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<{
+            validation: {
+                type: PropType<Record<string, any>>;
+                required: true;
+            };
+        }, () => import("vue").VNodeArrayChildren, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            validation: {
+                type: PropType<Record<string, any>>;
+                required: true;
+            };
+        }>>, {}, 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>;
+export default _default;
+//# sourceMappingURL=APolicyForm.vue.d.ts.map

package/dist/components/entities/policy/APolicyForm.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"APolicyForm.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/policy/APolicyForm.vue"],"names":[],"mappings":"AAoIA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAEpC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;;;cAoBnB,QAAQ,CAAC,MAAM,CAAC;;;cAGhB,QAAQ,CAAC,MAAM,CAAC;;;;;;;;;;;;cAHhB,QAAQ,CAAC,MAAM,CAAC;;;cAGhB,QAAQ,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAzB5C,GAnH+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAmH/B,GA7GqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+HrC,wBAgFG"}

package/dist/components/entities/policy/APolicyParentAssignment.d.ts

@@ -0,0 +1,36 @@
+import type { PropType } from 'vue';
+import type { Policy } from '@authup/core-kit';
+export declare const APolicyParentAssignment: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    entityId: {
+        type: StringConstructor;
+        required: true;
+    };
+    entity: {
+        type: PropType<Policy>;
+    };
+    parentId: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("../..").EntityVEmitOptions<Policy>, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entityId: {
+        type: StringConstructor;
+        required: true;
+    };
+    entity: {
+        type: PropType<Policy>;
+    };
+    parentId: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{
+    onUpdated?: (item: Policy) => any;
+    onDeleted?: (item: Policy) => any;
+    onCreated?: (item: Policy) => any;
+    onResolved?: (item?: Policy) => any;
+    onFailed?: (item: Error) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=APolicyParentAssignment.d.ts.map

package/dist/components/entities/policy/APolicyParentAssignment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"APolicyParentAssignment.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/policy/APolicyParentAssignment.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAEpC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAQ/C,eAAO,MAAM,uBAAuB;;;;;;cAOR,QAAQ,CAAC,MAAM,CAAC;;;;;;;;;;;;;;cAAhB,QAAQ,CAAC,MAAM,CAAC;;;;;;;;;;;;iFAqD1C,CAAC"}

package/dist/components/entities/policy/APolicyPicker.d.ts

@@ -0,0 +1,104 @@
+import type { Policy } from '@authup/core-kit';
+import type { SlotsType } from 'vue';
+import type { EntityPickerVSlots } from '../../utility';
+export declare const APolicyPicker: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    query: {
+        type: import("vue").PropType<import("rapiq").BuildInput<Policy>>;
+        default(): {};
+    };
+    realmId: {
+        type: StringConstructor;
+        default: any;
+    };
+    loadOnSetup: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: import("vue").PropType<boolean | import("../..").ListLoadingOptions<Policy>>;
+        default: boolean;
+    };
+    noMore: {
+        type: import("vue").PropType<boolean | import("../..").ListNoMoreOptions<Policy>>;
+        default: boolean;
+    };
+    footer: {
+        type: import("vue").PropType<boolean | import("../..").ListFooterOptions<Policy>>;
+        default: boolean;
+    };
+    header: {
+        type: import("vue").PropType<boolean | import("../..").ListHeaderOptions<Policy>>;
+        default: boolean;
+    };
+    body: {
+        type: import("vue").PropType<import("../..").ListBodyOptions<Policy>>;
+    };
+    value: {
+        type: import("vue").PropType<string[] | string | null>;
+    };
+    multiple: {
+        type: import("vue").PropType<boolean | undefined>;
+    };
+    parentId: {
+        type: StringConstructor;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (values: string[]) => true;
+} & import("../..").EntityCollectionVEmitOptions<Policy>, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    query: {
+        type: import("vue").PropType<import("rapiq").BuildInput<Policy>>;
+        default(): {};
+    };
+    realmId: {
+        type: StringConstructor;
+        default: any;
+    };
+    loadOnSetup: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: import("vue").PropType<boolean | import("../..").ListLoadingOptions<Policy>>;
+        default: boolean;
+    };
+    noMore: {
+        type: import("vue").PropType<boolean | import("../..").ListNoMoreOptions<Policy>>;
+        default: boolean;
+    };
+    footer: {
+        type: import("vue").PropType<boolean | import("../..").ListFooterOptions<Policy>>;
+        default: boolean;
+    };
+    header: {
+        type: import("vue").PropType<boolean | import("../..").ListHeaderOptions<Policy>>;
+        default: boolean;
+    };
+    body: {
+        type: import("vue").PropType<import("../..").ListBodyOptions<Policy>>;
+    };
+    value: {
+        type: import("vue").PropType<string[] | string | null>;
+    };
+    multiple: {
+        type: import("vue").PropType<boolean | undefined>;
+    };
+    parentId: {
+        type: StringConstructor;
+    };
+}>> & Readonly<{
+    onUpdated?: (item: Policy) => any;
+    onDeleted?: (item: Policy) => any;
+    onCreated?: (item: Policy) => any;
+    onChange?: (values: string[]) => any;
+}>, {
+    footer: boolean;
+    header: boolean;
+    query: import("rapiq").BuildInput<Policy>;
+    realmId: string;
+    loadOnSetup: boolean;
+    loading: boolean;
+    noMore: boolean;
+}, SlotsType<EntityPickerVSlots<Policy>>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=APolicyPicker.d.ts.map

package/dist/components/entities/policy/APolicyPicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"APolicyPicker.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/policy/APolicyPicker.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AAKrC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAIxD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+GAkCxB,CAAC"}

package/dist/components/entities/policy/APolicyTypePicker.vue.d.ts

@@ -0,0 +1,25 @@
+import type { PropType } from 'vue';
+import type { FormSelectOption } from '@vuecs/form-controls';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    type: {
+        type: StringConstructor;
+    };
+    types: {
+        type: PropType<(FormSelectOption | string)[]>;
+    };
+}>, {
+    option: import("vue").Ref<string, string>;
+    options: import("vue").ComputedRef<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<(FormSelectOption | string)[]>;
+    };
+}>> & Readonly<{
+    onPick?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=APolicyTypePicker.vue.d.ts.map

package/dist/components/entities/policy/APolicyTypePicker.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"APolicyTypePicker.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/policy/APolicyTypePicker.vue"],"names":[],"mappings":"AAgGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAEpC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;;;;;;cASlC,QAAQ,CAAC,CAAC,gBAAgB,GAAG,MAAM,CAAC,EAAE,CAAC;;;;;gBA4BvC,MAAM;;;;;;cA5BN,QAAQ,CAAC,CAAC,gBAAgB,GAAG,MAAM,CAAC,EAAE,CAAC;;;;;AANlE,wBA6CG"}