@authup/client-web-kit 1.0.0-beta.34 → 1.0.0-beta.36

package/dist/components/entities/identity-provider-role/AIdentityProviderRoleAssignment.vue.d.ts

@@ -0,0 +1,260 @@
+import type { PropType } from 'vue';
+import type { IdentityProviderRoleMapping, Role } from '@authup/core-kit';
+import { getVuelidateSeverity } from '../../../core';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    role: {
+        type: PropType<Role>;
+        required: true;
+    };
+    entityId: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, {
+    display: import("vue").Ref<boolean, boolean>;
+    toggleDisplay: () => void;
+    $v: import("vue").Ref<import("@vuelidate/core").Validation<{
+        name: {
+            minLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                min: number;
+            }, any>;
+            maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                max: number;
+            }, any>;
+        };
+        value: {
+            minLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                min: number;
+            }, any>;
+            maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                max: number;
+            }, any>;
+        };
+        value_is_regex: {};
+    }, {
+        name: string;
+        value: string;
+        value_is_regex: boolean;
+    }>, import("@vuelidate/core").Validation<{
+        name: {
+            minLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                min: number;
+            }, any>;
+            maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                max: number;
+            }, any>;
+        };
+        value: {
+            minLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                min: number;
+            }, any>;
+            maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                max: number;
+            }, any>;
+        };
+        value_is_regex: {};
+    }, {
+        name: string;
+        value: string;
+        value_is_regex: boolean;
+    }>>;
+    validationMessages: import("@ilingo/vuelidate").NestedValidationsTranslations<{
+        name: string;
+        value: string;
+        value_is_regex: boolean;
+    }>;
+    translationsDefault: Record<"name" | "delete" | "add" | "displayName" | "description" | "client" | "policy" | "realm" | "email" | "active" | "secret" | "scopes" | "create" | "update" | "generate" | "inactive" | "locked" | "notLocked" | "valueIsRegex" | "clients" | "clientScopes" | "externalId" | "hashed" | "overview" | "identityProviders" | "decisionStrategy" | "permissions" | "policies" | "robots" | "realms" | "roles" | "redirectUris" | "users", import("vue").Ref<string, string>>;
+    manager: import("../..").EntityManager<IdentityProviderRoleMapping>;
+    handleSaveOrCreate: (e: Event) => Promise<void>;
+    handleDelete: (e: Event) => Promise<void>;
+    getVuelidateSeverity: typeof getVuelidateSeverity;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("../..").EntityVEmitOptions<IdentityProviderRoleMapping>, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    role: {
+        type: PropType<Role>;
+        required: true;
+    };
+    entityId: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{
+    onUpdated?: (item: IdentityProviderRoleMapping) => any;
+    onDeleted?: (item: IdentityProviderRoleMapping) => any;
+    onCreated?: (item: IdentityProviderRoleMapping) => any;
+    onResolved?: (item?: IdentityProviderRoleMapping) => any;
+    onFailed?: (item: Error) => 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>;
+    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>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=AIdentityProviderRoleAssignment.vue.d.ts.map

package/dist/components/entities/identity-provider-role/AIdentityProviderRoleAssignment.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIdentityProviderRoleAssignment.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/identity-provider-role/AIdentityProviderRoleAssignment.vue"],"names":[],"mappings":"AA2OA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAEpC,OAAO,KAAK,EAAE,2BAA2B,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAE1E,OAAO,EAIH,oBAAoB,EAGvB,MAAM,eAAe,CAAC;wBAMF,OAAO,YAAY;AAAxC,wBAAyC;AAoNzC,QAAA,MAAM,YAAY;;cAQU,QAAQ,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAiEH,KAAK;sBAcX,KAAK;;;;cA/EV,QAAQ,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAhP1C,GAzMK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAyML,GAhMyB;;;;;;;oEAihBvB,CAAC"}

package/dist/components/entities/identity-provider-role/AIdentityProviderRoleAssignments.vue.d.ts

@@ -0,0 +1,350 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    entityId: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, {
+    forwardedSlots: import("vue").ComputedRef<{
+        [k: string]: import("vue").Slot<any>;
+    }>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entityId: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {
+    ARoles: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        query: {
+            type: import("vue").PropType<import("rapiq").BuildInput<import("@authup/core-kit").Role>>;
+            default(): {};
+        };
+        realmId: {
+            type: StringConstructor;
+            default: any;
+        };
+        loadOnSetup: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        loading: {
+            type: import("vue").PropType<boolean | import("../../index.ts").ListLoadingOptions<import("@authup/core-kit").Role>>;
+            default: boolean;
+        };
+        noMore: {
+            type: import("vue").PropType<boolean | import("../../index.ts").ListNoMoreOptions<import("@authup/core-kit").Role>>;
+            default: boolean;
+        };
+        footer: {
+            type: import("vue").PropType<boolean | import("../../index.ts").ListFooterOptions<import("@authup/core-kit").Role>>;
+            default: boolean;
+        };
+        header: {
+            type: import("vue").PropType<boolean | import("../../index.ts").ListHeaderOptions<import("@authup/core-kit").Role>>;
+            default: boolean;
+        };
+        body: {
+            type: import("vue").PropType<import("../../index.ts").ListBodyOptions<import("@authup/core-kit").Role>>;
+        };
+    }>, () => import("vue").VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("../../index.ts").EntityCollectionVEmitOptions<import("@authup/core-kit").Role>, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        query: {
+            type: import("vue").PropType<import("rapiq").BuildInput<import("@authup/core-kit").Role>>;
+            default(): {};
+        };
+        realmId: {
+            type: StringConstructor;
+            default: any;
+        };
+        loadOnSetup: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        loading: {
+            type: import("vue").PropType<boolean | import("../../index.ts").ListLoadingOptions<import("@authup/core-kit").Role>>;
+            default: boolean;
+        };
+        noMore: {
+            type: import("vue").PropType<boolean | import("../../index.ts").ListNoMoreOptions<import("@authup/core-kit").Role>>;
+            default: boolean;
+        };
+        footer: {
+            type: import("vue").PropType<boolean | import("../../index.ts").ListFooterOptions<import("@authup/core-kit").Role>>;
+            default: boolean;
+        };
+        header: {
+            type: import("vue").PropType<boolean | import("../../index.ts").ListHeaderOptions<import("@authup/core-kit").Role>>;
+            default: boolean;
+        };
+        body: {
+            type: import("vue").PropType<import("../../index.ts").ListBodyOptions<import("@authup/core-kit").Role>>;
+        };
+    }>> & Readonly<{
+        onUpdated?: (item: import("@authup/core-kit").Role) => any;
+        onDeleted?: (item: import("@authup/core-kit").Role) => any;
+        onCreated?: (item: import("@authup/core-kit").Role) => any;
+    }>, {
+        footer: boolean;
+        header: boolean;
+        query: import("rapiq").BuildInput<import("@authup/core-kit").Role>;
+        realmId: string;
+        loadOnSetup: boolean;
+        loading: boolean;
+        noMore: boolean;
+    }, import("vue").SlotsType<import("../../index.ts").EntityCollectionVSlots<import("@authup/core-kit").Role>>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    AIdentityProviderRoleAssignment: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        role: {
+            type: import("vue").PropType<import("@authup/core-kit").Role>;
+            required: true;
+        };
+        entityId: {
+            type: StringConstructor;
+            required: true;
+        };
+    }>, {
+        display: import("vue").Ref<boolean, boolean>;
+        toggleDisplay: () => void;
+        $v: import("vue").Ref<import("@vuelidate/core").Validation<{
+            name: {
+                minLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                    min: number;
+                }, any>;
+                maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                    max: number;
+                }, any>;
+            };
+            value: {
+                minLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                    min: number;
+                }, any>;
+                maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                    max: number;
+                }, any>;
+            };
+            value_is_regex: {};
+        }, {
+            name: string;
+            value: string;
+            value_is_regex: boolean;
+        }>, import("@vuelidate/core").Validation<{
+            name: {
+                minLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                    min: number;
+                }, any>;
+                maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                    max: number;
+                }, any>;
+            };
+            value: {
+                minLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                    min: number;
+                }, any>;
+                maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                    max: number;
+                }, any>;
+            };
+            value_is_regex: {};
+        }, {
+            name: string;
+            value: string;
+            value_is_regex: boolean;
+        }>>;
+        validationMessages: import("@ilingo/vuelidate").NestedValidationsTranslations<{
+            name: string;
+            value: string;
+            value_is_regex: boolean;
+        }>;
+        translationsDefault: Record<"name" | "delete" | "add" | "displayName" | "description" | "client" | "policy" | "realm" | "email" | "active" | "secret" | "scopes" | "create" | "update" | "generate" | "inactive" | "locked" | "notLocked" | "valueIsRegex" | "clients" | "clientScopes" | "externalId" | "hashed" | "overview" | "identityProviders" | "decisionStrategy" | "permissions" | "policies" | "robots" | "realms" | "roles" | "redirectUris" | "users", import("vue").Ref<string, string>>;
+        manager: import("../../index.ts").EntityManager<import("@authup/core-kit").IdentityProviderRoleMapping>;
+        handleSaveOrCreate: (e: Event) => Promise<void>;
+        handleDelete: (e: Event) => Promise<void>;
+        getVuelidateSeverity: typeof import("../../../index.ts").getVuelidateSeverity;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("../../index.ts").EntityVEmitOptions<import("@authup/core-kit").IdentityProviderRoleMapping>, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        role: {
+            type: import("vue").PropType<import("@authup/core-kit").Role>;
+            required: true;
+        };
+        entityId: {
+            type: StringConstructor;
+            required: true;
+        };
+    }>> & Readonly<{
+        onUpdated?: (item: import("@authup/core-kit").IdentityProviderRoleMapping) => any;
+        onDeleted?: (item: import("@authup/core-kit").IdentityProviderRoleMapping) => any;
+        onCreated?: (item: import("@authup/core-kit").IdentityProviderRoleMapping) => any;
+        onResolved?: (item?: import("@authup/core-kit").IdentityProviderRoleMapping) => any;
+        onFailed?: (item: Error) => 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: import("vue").PropType<`${import("@vuecs/form-controls").ValidationSeverity}` | undefined>;
+                default: any;
+            };
+            validationMessages: {
+                type: import("vue").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: import("vue").PropType<`${import("@vuecs/form-controls").ValidationSeverity}` | undefined>;
+                default: any;
+            };
+            validationMessages: {
+                type: import("vue").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>;
+        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: import("vue").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: import("vue").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>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=AIdentityProviderRoleAssignments.vue.d.ts.map

package/dist/components/entities/identity-provider-role/AIdentityProviderRoleAssignments.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIdentityProviderRoleAssignments.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/identity-provider-role/AIdentityProviderRoleAssignments.vue"],"names":[],"mappings":"wBAuDqB,OAAO,YAAY;AAAxC,wBAAyC;AAsEzC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCA1ElB,GAnBS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAmBT,GAZ4B;;;;;;;;oEAkG1B,CAAC"}

package/dist/components/entities/identity-provider-role/index.d.ts

@@ -1,3 +1,3 @@
-export { AIdentityProviderRoleAssignments } from './AIdentityProviderRoleAssignments';
-export { AIdentityProviderRoleAssignment } from './AIdentityProviderRoleAssignment';
+export { default as AIdentityProviderRoleAssignments } from './AIdentityProviderRoleAssignments.vue';
+export { default as AIdentityProviderRoleAssignment } from './AIdentityProviderRoleAssignment.vue';
 //# sourceMappingURL=index.d.ts.map

package/dist/components/entities/identity-provider-role/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/identity-provider-role/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,gCAAgC,EAAE,MAAM,oCAAoC,CAAC;AACtF,OAAO,EAAE,+BAA+B,EAAE,MAAM,mCAAmC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/identity-provider-role/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,OAAO,IAAI,gCAAgC,EAAE,MAAM,wCAAwC,CAAC;AACrG,OAAO,EAAE,OAAO,IAAI,+BAA+B,EAAE,MAAM,uCAAuC,CAAC"}

package/dist/components/entities/index.d.ts

@@ -7,6 +7,7 @@ export * from './identity-provider-role';
 export * from './policy';
 export * from './permission';
 export * from './permission-client';
+export * from './permission-policy-binding';
 export * from './permission-policy';
 export * from './permission-robot';
 export * from './permission-role';

package/dist/components/entities/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/entities/index.ts"],"names":[],"mappings":"AAOA,cAAc,UAAU,CAAC;AACzB,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,QAAQ,CAAC;AACvB,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,QAAQ,CAAC;AACvB,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/entities/index.ts"],"names":[],"mappings":"AAOA,cAAc,UAAU,CAAC;AACzB,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,QAAQ,CAAC;AACvB,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,QAAQ,CAAC;AACvB,cAAc,aAAa,CAAC"}

package/dist/components/entities/permission/APermissionForm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"APermissionForm.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/permission/APermissionForm.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGnD,OAAO,KAAK,EAAE,QAAQ,EAAsB,MAAM,KAAK,CAAC;AAgCxD,eAAO,MAAM,eAAe;;cACW,QAAQ,CAAC,UAAU,CAAC;;;;;;cAApB,QAAQ,CAAC,UAAU,CAAC;;;;;;;;iFA8KzD,CAAC"}
+{"version":3,"file":"APermissionForm.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/permission/APermissionForm.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAInD,OAAO,KAAK,EAAE,QAAQ,EAAsB,MAAM,KAAK,CAAC;AAmDxD,eAAO,MAAM,eAAe;;cACW,QAAQ,CAAC,UAAU,CAAC;;;;;;cAApB,QAAQ,CAAC,UAAU,CAAC;;;;;;;;iFA+MzD,CAAC"}