@authup/client-web-kit 1.0.0-beta.27 → 1.0.0-beta.29

package/dist/components/entities/client/AClientForm.vue.d.ts

@@ -0,0 +1,570 @@
+import { type PropType } from 'vue';
+import { type Client } from '@authup/core-kit';
+import { TranslatorTranslationDefaultKey } from '../../../core';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        default: any;
+    };
+    entity: {
+        type: PropType<Client>;
+        default: any;
+    };
+    realmId: {
+        type: StringConstructor;
+        default: any;
+    };
+}>, {
+    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" | "permissions" | "policies" | "robots" | "realms" | "roles" | "redirectUris" | "users", import("vue").Ref<string, string>>;
+    translationsClient: Record<"nameHint" | "descriptionHint" | "redirectURIHint" | "isConfidential" | "isActive" | "hashSecret", import("vue").Ref<string, string>>;
+    vuelidate: import("vue").Ref<import("@vuelidate/core").Validation<{
+        active: {
+            required: import("@vuelidate/core").ValidationRuleWithoutParams<any>;
+        };
+        name: {
+            required: import("@vuelidate/core").ValidationRuleWithoutParams<any>;
+            alphaUpperNumHyphenUnderscoreDot: any;
+            minLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                min: number;
+            }, any>;
+            maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                max: number;
+            }, any>;
+        };
+        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: {
+            required: import("@vuelidate/core").ValidationRuleWithoutParams<any>;
+        };
+        redirect_uri: {
+            maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                max: number;
+            }, any>;
+        };
+        is_confidential: {};
+        secret: {
+            minLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                min: number;
+            }, any>;
+            maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                max: number;
+            }, any>;
+        };
+        secret_hashed: {};
+    }, {
+        active: boolean;
+        name: string;
+        display_name: string;
+        description: string;
+        realm_id: string;
+        redirect_uri: string;
+        base_url: string;
+        root_url: string;
+        is_confidential: boolean;
+        secret: string;
+        secret_hashed: boolean;
+    }>, import("@vuelidate/core").Validation<{
+        active: {
+            required: import("@vuelidate/core").ValidationRuleWithoutParams<any>;
+        };
+        name: {
+            required: import("@vuelidate/core").ValidationRuleWithoutParams<any>;
+            alphaUpperNumHyphenUnderscoreDot: any;
+            minLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                min: number;
+            }, any>;
+            maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                max: number;
+            }, any>;
+        };
+        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: {
+            required: import("@vuelidate/core").ValidationRuleWithoutParams<any>;
+        };
+        redirect_uri: {
+            maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                max: number;
+            }, any>;
+        };
+        is_confidential: {};
+        secret: {
+            minLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                min: number;
+            }, any>;
+            maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                max: number;
+            }, any>;
+        };
+        secret_hashed: {};
+    }, {
+        active: boolean;
+        name: string;
+        display_name: string;
+        description: string;
+        realm_id: string;
+        redirect_uri: string;
+        base_url: string;
+        root_url: string;
+        is_confidential: boolean;
+        secret: string;
+        secret_hashed: boolean;
+    }>>;
+    data: import("vue").Ref<Client, Client>;
+    isNameFixed: import("vue").ComputedRef<boolean>;
+    isBusy: boolean;
+    isEditing: import("vue").ComputedRef<boolean>;
+    isSecretHashed: import("vue").ComputedRef<boolean>;
+    generateSecret: () => string;
+    redirectUris: import("vue").ComputedRef<string[]>;
+    submit: () => Promise<void>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("../..").EntityVEmitOptions<Client>, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        default: any;
+    };
+    entity: {
+        type: PropType<Client>;
+        default: any;
+    };
+    realmId: {
+        type: StringConstructor;
+        default: any;
+    };
+}>> & Readonly<{
+    onUpdated?: (item: Client) => any;
+    onDeleted?: (item: Client) => any;
+    onCreated?: (item: Client) => any;
+    onResolved?: (item?: Client) => any;
+    onFailed?: (item: Error) => any;
+}>, {
+    name: string;
+    realmId: string;
+    entity: Client;
+}, {}, {
+    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>;
+    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>;
+    AFormInputList: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        names: {
+            type: PropType<string[]>;
+            default: () => any[];
+        };
+        minItems: {
+            type: NumberConstructor;
+            default: number;
+        };
+        maxItems: {
+            type: NumberConstructor;
+            default: number;
+        };
+    }>, {
+        add: (item?: string) => void;
+        canAdd: import("vue").ComputedRef<boolean>;
+        canDrop: import("vue").ComputedRef<boolean>;
+        handleDeleted: (id: number) => void;
+        handleUpdated: (id: number, value: string) => void;
+        items: import("vue").Ref<{
+            id: number;
+            value: string;
+        }[], {
+            id: number;
+            value: string;
+        }[] | {
+            id: number;
+            value: string;
+        }[]>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "changed"[], "changed", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        names: {
+            type: PropType<string[]>;
+            default: () => any[];
+        };
+        minItems: {
+            type: NumberConstructor;
+            default: number;
+        };
+        maxItems: {
+            type: NumberConstructor;
+            default: number;
+        };
+    }>> & Readonly<{
+        onChanged?: (...args: any[]) => any;
+    }>, {
+        names: string[];
+        minItems: number;
+        maxItems: number;
+    }, {}, {
+        ATranslationDefault: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            name: {
+                type: PropType<`${TranslatorTranslationDefaultKey}`>;
+                required: true;
+            };
+        }>, () => 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<{
+            name: {
+                type: PropType<`${TranslatorTranslationDefaultKey}`>;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        AFormInputListItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            name: {
+                type: StringConstructor;
+                default: any;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            handleUpdated: () => void;
+            handleDeleted: () => void;
+            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>;
+                };
+            }, {
+                name: 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>;
+                };
+            }, {
+                name: string;
+            }>>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("updated" | "deleted")[], "updated" | "deleted", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            name: {
+                type: StringConstructor;
+                default: any;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onUpdated?: (...args: any[]) => any;
+            onDeleted?: (...args: any[]) => any;
+        }>, {
+            name: string;
+            disabled: boolean;
+        }, {}, {
+            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>;
+            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>;
+            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>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, 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>;
+//# sourceMappingURL=AClientForm.vue.d.ts.map

package/dist/components/entities/client/AClientForm.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AClientForm.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/client/AClientForm.vue"],"names":[],"mappings":"AAgcA,OAAO,EACH,KAAK,QAAQ,EAChB,MAAM,KAAK,CAAC;AAKb,OAAO,EAAE,KAAK,MAAM,EAAc,MAAM,kBAAkB,CAAC;AAO3D,OAAO,EAEH,+BAA+B,EAIlC,MAAM,eAAe,CAAC;wBAGF,OAAO,YAAY;AAAxC,wBAAyC;AAgnBzC,QAAA,MAAM,YAAY;;;;;;cAUU,QAAQ,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAhB,QAAQ,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAjpB5C,GApae;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEA+uCb,CAAC"}

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

@@ -1,5 +1,5 @@
 export { AClient } from './AClient';
-export { AClientForm } from './AClientForm';
+export { default as AClientForm } from './AClientForm.vue';
 export { AClientPicker } from './AClientPicker';
 export { AClients } from './AClients';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/client/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/client/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}

package/dist/components/entities/client-role/AClientRoleAssignments.d.ts

@@ -1,9 +1,11 @@
 export declare const AClientRoleAssignments: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     entityId: StringConstructor;
+    realmId: StringConstructor;
 }>, () => 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<{
     entityId: StringConstructor;
+    realmId: StringConstructor;
 }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default AClientRoleAssignments;
 //# sourceMappingURL=AClientRoleAssignments.d.ts.map

package/dist/components/entities/client-role/AClientRoleAssignments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AClientRoleAssignments.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/client-role/AClientRoleAssignments.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,sBAAsB;;;;;;iGAiBjC,CAAC;AAEH,eAAe,sBAAsB,CAAC"}
+{"version":3,"file":"AClientRoleAssignments.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/client-role/AClientRoleAssignments.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,sBAAsB;;;;;;;;iGAwBjC,CAAC;AAEH,eAAe,sBAAsB,CAAC"}

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

@@ -1,5 +1,7 @@
 import { IdentityProviderPreset, IdentityProviderProtocol } from '@authup/core-kit';
-declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     protocol: {
         type: StringConstructor;
     };
@@ -52,5 +54,4 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         };
     }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-export default _default;
 //# sourceMappingURL=AIdentityProviderPicker.vue.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"AIdentityProviderPicker.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/identity-provider/AIdentityProviderPicker.vue"],"names":[],"mappings":"AA4HA,OAAO,EAAE,sBAAsB,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;;;;;;;;;;;6BAuB5C,MAAM;yBAIV,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAtB1C,wBAiCG"}
+{"version":3,"file":"AIdentityProviderPicker.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/identity-provider/AIdentityProviderPicker.vue"],"names":[],"mappings":"AA6HA,OAAO,EAAE,sBAAsB,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;wBAK/D,OAAO,YAAY;AAAxC,wBAAyC;AAwJzC,QAAA,MAAM,YAAY;;;;;;;;;;6BAkBsB,MAAM;yBAIV,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEAWxC,CAAC"}

package/dist/components/entities/permission/APermissionCheck.d.ts

@@ -1,4 +1,4 @@
-import type { PermissionCheckerCheckOptions, PolicyInput } from '@authup/access';
+import type { PermissionCheckerCheckOptions } from '@authup/access';
 import type { PropType } from 'vue';
 export declare const APermissionCheck: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     name: {
@@ -6,7 +6,7 @@ export declare const APermissionCheck: import("vue").DefineComponent<import("vue
         required: true;
     };
     input: {
-        type: PropType<PolicyInput>;
+        type: PropType<Record<string, any>>;
     };
     options: {
         type: PropType<PermissionCheckerCheckOptions>;
@@ -21,7 +21,7 @@ export declare const APermissionCheck: import("vue").DefineComponent<import("vue
         required: true;
     };
     input: {
-        type: PropType<PolicyInput>;
+        type: PropType<Record<string, any>>;
     };
     options: {
         type: PropType<PermissionCheckerCheckOptions>;

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

@@ -1 +1 @@
-{"version":3,"file":"APermissionCheck.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/permission/APermissionCheck.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,6BAA6B,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAEjF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAIpC,eAAO,MAAM,gBAAgB;;cAGQ,QAAQ,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC;;;;cAIpC,QAAQ,CAAC,WAAW,CAAC;;;cAGrB,QAAQ,CAAC,6BAA6B,CAAC;;;;;;;;cAP9B,QAAQ,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC;;;;cAIpC,QAAQ,CAAC,WAAW,CAAC;;;cAGrB,QAAQ,CAAC,6BAA6B,CAAC;;iGAuBjE,CAAC"}
+{"version":3,"file":"APermissionCheck.d.ts","sourceRoot":"","sources":["../../../../src/components/entities/permission/APermissionCheck.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAC;AAGpE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAIpC,eAAO,MAAM,gBAAgB;;cAGQ,QAAQ,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC;;;;cAIpC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;;;cAG7B,QAAQ,CAAC,6BAA6B,CAAC;;;;;;;;cAP9B,QAAQ,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC;;;;cAIpC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;;;cAG7B,QAAQ,CAAC,6BAA6B,CAAC;;iGAuBjE,CAAC"}

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

@@ -1,7 +1,9 @@
 import { type PropType } from 'vue';
 import type { Policy } from '@authup/core-kit';
 import type { FormSelectOption } from '@vuecs/form-controls';
-declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     entity: {
         type: PropType<Policy>;
     };
@@ -364,5 +366,4 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: import("@ilingo/vuelidate").SlotProps;
     }>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-export default _default;
 //# sourceMappingURL=APolicyBasicForm.vue.d.ts.map