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

package/dist/components/entities/permission-client/APermissionClientAssignments.vue.d.ts

@@ -0,0 +1,178 @@
+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<{}>, {}, {}, {
+    AClients: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        query: {
+            type: import("vue").PropType<import("rapiq").BuildInput<import("@authup/core-kit").Client>>;
+            default(): {};
+        };
+        realmId: {
+            type: StringConstructor;
+            default: any;
+        };
+        loadOnSetup: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        loading: {
+            type: import("vue").PropType<boolean | import("../..").ListLoadingOptions<import("@authup/core-kit").Client>>;
+            default: boolean;
+        };
+        noMore: {
+            type: import("vue").PropType<boolean | import("../..").ListNoMoreOptions<import("@authup/core-kit").Client>>;
+            default: boolean;
+        };
+        footer: {
+            type: import("vue").PropType<boolean | import("../..").ListFooterOptions<import("@authup/core-kit").Client>>;
+            default: boolean;
+        };
+        header: {
+            type: import("vue").PropType<boolean | import("../..").ListHeaderOptions<import("@authup/core-kit").Client>>;
+            default: boolean;
+        };
+        body: {
+            type: import("vue").PropType<import("../..").ListBodyOptions<import("@authup/core-kit").Client>>;
+        };
+    }>, () => import("vue").VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("../..").EntityCollectionVEmitOptions<import("@authup/core-kit").Client>, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        query: {
+            type: import("vue").PropType<import("rapiq").BuildInput<import("@authup/core-kit").Client>>;
+            default(): {};
+        };
+        realmId: {
+            type: StringConstructor;
+            default: any;
+        };
+        loadOnSetup: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        loading: {
+            type: import("vue").PropType<boolean | import("../..").ListLoadingOptions<import("@authup/core-kit").Client>>;
+            default: boolean;
+        };
+        noMore: {
+            type: import("vue").PropType<boolean | import("../..").ListNoMoreOptions<import("@authup/core-kit").Client>>;
+            default: boolean;
+        };
+        footer: {
+            type: import("vue").PropType<boolean | import("../..").ListFooterOptions<import("@authup/core-kit").Client>>;
+            default: boolean;
+        };
+        header: {
+            type: import("vue").PropType<boolean | import("../..").ListHeaderOptions<import("@authup/core-kit").Client>>;
+            default: boolean;
+        };
+        body: {
+            type: import("vue").PropType<import("../..").ListBodyOptions<import("@authup/core-kit").Client>>;
+        };
+    }>> & Readonly<{
+        onUpdated?: (item: import("@authup/core-kit").Client) => any;
+        onDeleted?: (item: import("@authup/core-kit").Client) => any;
+        onCreated?: (item: import("@authup/core-kit").Client) => any;
+    }>, {
+        footer: boolean;
+        header: boolean;
+        query: import("rapiq").BuildInput<import("@authup/core-kit").Client>;
+        realmId: string;
+        loadOnSetup: boolean;
+        loading: boolean;
+        noMore: boolean;
+    }, import("vue").SlotsType<import("../..").EntityCollectionVSlots<import("@authup/core-kit").Client>>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    AClientPermissionAssignment: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        clientId: {
+            type: StringConstructor;
+            required: true;
+        };
+        permissionId: {
+            type: StringConstructor;
+            required: true;
+        };
+    }>, {
+        manager: import("../..").EntityManager<import("@authup/core-kit").ClientPermission>;
+        handleChanged: (value: boolean) => Promise<void>;
+        handleUpdated: (entity: import("@authup/core-kit").ClientPermission) => void;
+        EntityType: typeof import("@authup/core-kit").EntityType;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("../..").EntityVEmitOptions<import("@authup/core-kit").ClientPermission>, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        clientId: {
+            type: StringConstructor;
+            required: true;
+        };
+        permissionId: {
+            type: StringConstructor;
+            required: true;
+        };
+    }>> & Readonly<{
+        onUpdated?: (item: import("@authup/core-kit").ClientPermission) => any;
+        onDeleted?: (item: import("@authup/core-kit").ClientPermission) => any;
+        onCreated?: (item: import("@authup/core-kit").ClientPermission) => any;
+        onResolved?: (item?: import("@authup/core-kit").ClientPermission) => any;
+        onFailed?: (item: Error) => any;
+    }>, {}, {}, {
+        AToggleButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            value: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            isBusy: {
+                type: BooleanConstructor;
+                required: true;
+            };
+        }>, {
+            handleClick: (e: Event) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "changed"[], "changed", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            value: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            isBusy: {
+                type: BooleanConstructor;
+                required: true;
+            };
+        }>> & Readonly<{
+            onChanged?: (...args: any[]) => any;
+        }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        APermissionPolicyBindingButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            entityType: {
+                type: import("vue").PropType<keyof import("@authup/core-kit").EntityTypeMap>;
+                required: true;
+            };
+            entity: {
+                type: import("vue").PropType<import("@authup/core-kit").PermissionRelation & {
+                    id: string;
+                }>;
+                required: true;
+            };
+        }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("updated" | "failed")[], "updated" | "failed", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            entityType: {
+                type: import("vue").PropType<keyof import("@authup/core-kit").EntityTypeMap>;
+                required: true;
+            };
+            entity: {
+                type: import("vue").PropType<import("@authup/core-kit").PermissionRelation & {
+                    id: string;
+                }>;
+                required: true;
+            };
+        }>> & Readonly<{
+            onUpdated?: (...args: any[]) => any;
+            onFailed?: (...args: any[]) => any;
+        }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=APermissionClientAssignments.vue.d.ts.map

package/dist/components/entities/permission-client/APermissionClientAssignments.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"APermissionClientAssignments.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/permission-client/APermissionClientAssignments.vue"],"names":[],"mappings":"wBAsDqB,OAAO,YAAY;AAAxC,wBAAyC;AAgEzC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEAYhB,CAAC"}

package/dist/components/entities/permission-client/index.d.ts

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

package/dist/components/entities/permission-client/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/permission-client/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/permission-client/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,OAAO,IAAI,4BAA4B,EAAE,MAAM,oCAAoC,CAAC"}

package/dist/components/entities/permission-policy/APermissionPolicyAssignment.vue.d.ts

@@ -0,0 +1,56 @@
+import type { PermissionPolicy } from '@authup/core-kit';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    permissionId: {
+        type: StringConstructor;
+        required: true;
+    };
+    policyId: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, {
+    manager: import("../../index.ts").EntityManager<PermissionPolicy>;
+    handleChanged: (value: boolean) => Promise<void>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("../../index.ts").EntityVEmitOptions<PermissionPolicy>, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    permissionId: {
+        type: StringConstructor;
+        required: true;
+    };
+    policyId: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{
+    onUpdated?: (item: PermissionPolicy) => any;
+    onDeleted?: (item: PermissionPolicy) => any;
+    onCreated?: (item: PermissionPolicy) => any;
+    onResolved?: (item?: PermissionPolicy) => any;
+    onFailed?: (item: Error) => any;
+}>, {}, {}, {
+    AToggleButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        value: {
+            type: BooleanConstructor;
+            required: true;
+        };
+        isBusy: {
+            type: BooleanConstructor;
+            required: true;
+        };
+    }>, {
+        handleClick: (e: Event) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "changed"[], "changed", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        value: {
+            type: BooleanConstructor;
+            required: true;
+        };
+        isBusy: {
+            type: BooleanConstructor;
+            required: true;
+        };
+    }>> & Readonly<{
+        onChanged?: (...args: any[]) => any;
+    }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=APermissionPolicyAssignment.vue.d.ts.map

package/dist/components/entities/permission-policy/APermissionPolicyAssignment.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"APermissionPolicyAssignment.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/permission-policy/APermissionPolicyAssignment.vue"],"names":[],"mappings":"AAsFA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;wBAQpC,OAAO,YAAY;AAAxC,wBAAyC;AAkCzC,QAAA,MAAM,YAAY;;;;;;;;;;;2BAwCoB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEAgB3C,CAAC"}

package/dist/components/entities/permission-policy/APermissionPolicyAssignments.vue.d.ts

@@ -0,0 +1,357 @@
+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<{
+    entityId: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, {
+    detailPolicy: import("vue").Ref<{
+        id: string;
+        built_in: boolean;
+        type: string;
+        name: string;
+        display_name: string | null;
+        description: string | null;
+        invert: boolean;
+        children: {
+            id: string;
+            built_in: boolean;
+            type: string;
+            name: string;
+            display_name: string | null;
+            description: string | null;
+            invert: boolean;
+            children: /*elided*/ any[];
+            parent_id: Policy["id"] | null;
+            parent: /*elided*/ any;
+            realm_id: import("@authup/core-kit").Realm["id"] | null;
+            realm: {
+                id: string;
+                name: string;
+                display_name: string | null;
+                description: string | null;
+                built_in: boolean;
+                created_at: string;
+                updated_at: string;
+            };
+            created_at: string;
+            updated_at: string;
+        }[];
+        parent_id: Policy["id"] | null;
+        parent: {
+            id: string;
+            built_in: boolean;
+            type: string;
+            name: string;
+            display_name: string | null;
+            description: string | null;
+            invert: boolean;
+            children: /*elided*/ any[];
+            parent_id: Policy["id"] | null;
+            parent: /*elided*/ any;
+            realm_id: import("@authup/core-kit").Realm["id"] | null;
+            realm: {
+                id: string;
+                name: string;
+                display_name: string | null;
+                description: string | null;
+                built_in: boolean;
+                created_at: string;
+                updated_at: string;
+            };
+            created_at: string;
+            updated_at: string;
+        };
+        realm_id: import("@authup/core-kit").Realm["id"] | null;
+        realm: {
+            id: string;
+            name: string;
+            display_name: string | null;
+            description: string | null;
+            built_in: boolean;
+            created_at: string;
+            updated_at: string;
+        };
+        created_at: string;
+        updated_at: string;
+    }, Policy | {
+        id: string;
+        built_in: boolean;
+        type: string;
+        name: string;
+        display_name: string | null;
+        description: string | null;
+        invert: boolean;
+        children: {
+            id: string;
+            built_in: boolean;
+            type: string;
+            name: string;
+            display_name: string | null;
+            description: string | null;
+            invert: boolean;
+            children: /*elided*/ any[];
+            parent_id: Policy["id"] | null;
+            parent: /*elided*/ any;
+            realm_id: import("@authup/core-kit").Realm["id"] | null;
+            realm: {
+                id: string;
+                name: string;
+                display_name: string | null;
+                description: string | null;
+                built_in: boolean;
+                created_at: string;
+                updated_at: string;
+            };
+            created_at: string;
+            updated_at: string;
+        }[];
+        parent_id: Policy["id"] | null;
+        parent: {
+            id: string;
+            built_in: boolean;
+            type: string;
+            name: string;
+            display_name: string | null;
+            description: string | null;
+            invert: boolean;
+            children: /*elided*/ any[];
+            parent_id: Policy["id"] | null;
+            parent: /*elided*/ any;
+            realm_id: import("@authup/core-kit").Realm["id"] | null;
+            realm: {
+                id: string;
+                name: string;
+                display_name: string | null;
+                description: string | null;
+                built_in: boolean;
+                created_at: string;
+                updated_at: string;
+            };
+            created_at: string;
+            updated_at: string;
+        };
+        realm_id: import("@authup/core-kit").Realm["id"] | null;
+        realm: {
+            id: string;
+            name: string;
+            display_name: string | null;
+            description: string | null;
+            built_in: boolean;
+            created_at: string;
+            updated_at: string;
+        };
+        created_at: string;
+        updated_at: string;
+    }>;
+    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<{}>, {}, {}, {
+    APolicies: 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("../../index.ts").ListLoadingOptions<Policy>>;
+            default: boolean;
+        };
+        noMore: {
+            type: import("vue").PropType<boolean | import("../../index.ts").ListNoMoreOptions<Policy>>;
+            default: boolean;
+        };
+        footer: {
+            type: import("vue").PropType<boolean | import("../../index.ts").ListFooterOptions<Policy>>;
+            default: boolean;
+        };
+        header: {
+            type: import("vue").PropType<boolean | import("../../index.ts").ListHeaderOptions<Policy>>;
+            default: boolean;
+        };
+        body: {
+            type: import("vue").PropType<import("../../index.ts").ListBodyOptions<Policy>>;
+        };
+    }>, () => import("vue").VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("../../index.ts").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("../../index.ts").ListLoadingOptions<Policy>>;
+            default: boolean;
+        };
+        noMore: {
+            type: import("vue").PropType<boolean | import("../../index.ts").ListNoMoreOptions<Policy>>;
+            default: boolean;
+        };
+        footer: {
+            type: import("vue").PropType<boolean | import("../../index.ts").ListFooterOptions<Policy>>;
+            default: boolean;
+        };
+        header: {
+            type: import("vue").PropType<boolean | import("../../index.ts").ListHeaderOptions<Policy>>;
+            default: boolean;
+        };
+        body: {
+            type: import("vue").PropType<import("../../index.ts").ListBodyOptions<Policy>>;
+        };
+    }>> & Readonly<{
+        onUpdated?: (item: Policy) => any;
+        onDeleted?: (item: Policy) => any;
+        onCreated?: (item: Policy) => any;
+    }>, {
+        footer: boolean;
+        header: boolean;
+        query: import("rapiq").BuildInput<Policy>;
+        realmId: string;
+        loadOnSetup: boolean;
+        loading: boolean;
+        noMore: boolean;
+    }, import("vue").SlotsType<import("../../index.ts").EntityCollectionVSlots<Policy>>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    APermissionPolicyAssignment: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        permissionId: {
+            type: StringConstructor;
+            required: true;
+        };
+        policyId: {
+            type: StringConstructor;
+            required: true;
+        };
+    }>, {
+        manager: import("../../index.ts").EntityManager<import("@authup/core-kit").PermissionPolicy>;
+        handleChanged: (value: boolean) => Promise<void>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("../../index.ts").EntityVEmitOptions<import("@authup/core-kit").PermissionPolicy>, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        permissionId: {
+            type: StringConstructor;
+            required: true;
+        };
+        policyId: {
+            type: StringConstructor;
+            required: true;
+        };
+    }>> & Readonly<{
+        onUpdated?: (item: import("@authup/core-kit").PermissionPolicy) => any;
+        onDeleted?: (item: import("@authup/core-kit").PermissionPolicy) => any;
+        onCreated?: (item: import("@authup/core-kit").PermissionPolicy) => any;
+        onResolved?: (item?: import("@authup/core-kit").PermissionPolicy) => any;
+        onFailed?: (item: Error) => any;
+    }>, {}, {}, {
+        AToggleButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            value: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            isBusy: {
+                type: BooleanConstructor;
+                required: true;
+            };
+        }>, {
+            handleClick: (e: Event) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "changed"[], "changed", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            value: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            isBusy: {
+                type: BooleanConstructor;
+                required: true;
+            };
+        }>> & Readonly<{
+            onChanged?: (...args: any[]) => any;
+        }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    APolicyInlineInfo: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        entity: {
+            type: import("vue").PropType<Policy>;
+            required: true;
+        };
+    }>, {
+        handleDetail: () => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "detail"[], "detail", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        entity: {
+            type: import("vue").PropType<Policy>;
+            required: true;
+        };
+    }>> & Readonly<{
+        onDetail?: (...args: any[]) => any;
+    }>, {}, {}, {
+        APolicyTypeBadge: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            type: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>, {
+            typeLabels: Record<string, string>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            type: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        APolicyDetailNav: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            policyId: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>, {
+            handleClick: (e: Event) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            policyId: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>> & Readonly<{
+            onClick?: (...args: any[]) => any;
+        }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    APolicySummary: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        entity: {
+            type: import("vue").PropType<Policy>;
+            required: true;
+        };
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        entity: {
+            type: import("vue").PropType<Policy>;
+            required: true;
+        };
+    }>> & Readonly<{}>, {}, {}, {
+        APolicyTypeBadge: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            type: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>, {
+            typeLabels: Record<string, string>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            type: {
+                type: StringConstructor;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=APermissionPolicyAssignments.vue.d.ts.map

package/dist/components/entities/permission-policy/APermissionPolicyAssignments.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"APermissionPolicyAssignments.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/permission-policy/APermissionPolicyAssignments.vue"],"names":[],"mappings":"AAgJA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;wBAa1B,OAAO,YAAY;AAAxC,wBAAyC;AA2MzC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEAkChB,CAAC"}

package/dist/components/entities/permission-policy/index.d.ts

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

package/dist/components/entities/permission-policy/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/permission-policy/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/permission-policy/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,OAAO,IAAI,2BAA2B,EAAE,MAAM,mCAAmC,CAAC;AAC3F,OAAO,EAAE,OAAO,IAAI,4BAA4B,EAAE,MAAM,oCAAoC,CAAC"}

package/dist/components/entities/permission-policy-binding/APermissionPolicyBindingButton.d.ts

@@ -0,0 +1,31 @@
+import type { EntityTypeMap, PermissionRelation } from '@authup/core-kit';
+import type { PropType } from 'vue';
+type PermissionBindingEntity = PermissionRelation & {
+    id: string;
+};
+export declare const APermissionPolicyBindingButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    entityType: {
+        type: PropType<keyof EntityTypeMap>;
+        required: true;
+    };
+    entity: {
+        type: PropType<PermissionBindingEntity>;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("updated" | "failed")[], "updated" | "failed", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entityType: {
+        type: PropType<keyof EntityTypeMap>;
+        required: true;
+    };
+    entity: {
+        type: PropType<PermissionBindingEntity>;
+        required: true;
+    };
+}>> & Readonly<{
+    onUpdated?: (...args: any[]) => any;
+    onFailed?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export {};
+//# sourceMappingURL=APermissionPolicyBindingButton.d.ts.map

package/dist/components/entities/permission-policy-binding/APermissionPolicyBindingButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"APermissionPolicyBindingButton.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/permission-policy-binding/APermissionPolicyBindingButton.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAU,MAAM,kBAAkB,CAAC;AAClF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAkBpC,KAAK,uBAAuB,GAAG,kBAAkB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnE,eAAO,MAAM,8BAA8B;;cAGf,QAAQ,CAAC,MAAM,aAAa,CAAC;;;;cAI7B,QAAQ,CAAC,uBAAuB,CAAC;;;;;;;cAJjC,QAAQ,CAAC,MAAM,aAAa,CAAC;;;;cAI7B,QAAQ,CAAC,uBAAuB,CAAC;;;;;;iFAwN3D,CAAC"}

package/dist/components/entities/permission-policy-binding/index.d.ts

@@ -0,0 +1,2 @@
+export { APermissionPolicyBindingButton } from './APermissionPolicyBindingButton';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/entities/permission-policy-binding/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/permission-policy-binding/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,8BAA8B,EAAE,MAAM,kCAAkC,CAAC"}