@authup/client-web-kit 1.0.0-beta.26 → 1.0.0-beta.28

package/dist/components/workflows/authorize/Authorize.vue.d.ts

@@ -0,0 +1,489 @@
+import type { Client, OAuth2AuthorizationCodeRequest, Scope } from '@authup/core-kit';
+import type { PropType, VNodeChild } from 'vue';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    codeRequest: {
+        type: PropType<OAuth2AuthorizationCodeRequest>;
+    };
+    client: {
+        type: PropType<Client>;
+    };
+    clientId: {
+        type: StringConstructor;
+    };
+    scopes: {
+        type: PropType<Scope[]>;
+    };
+    error: {
+        type: PropType<Error>;
+    };
+}>, () => any[] | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "redirect"[], "redirect", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    codeRequest: {
+        type: PropType<OAuth2AuthorizationCodeRequest>;
+    };
+    client: {
+        type: PropType<Client>;
+    };
+    clientId: {
+        type: StringConstructor;
+    };
+    scopes: {
+        type: PropType<Scope[]>;
+    };
+    error: {
+        type: PropType<Error>;
+    };
+}>> & Readonly<{
+    onRedirect?: (...args: any[]) => any;
+}>, {}, {}, {
+    AuthorizeText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        isError: {
+            type: BooleanConstructor;
+        };
+        message: {
+            type: StringConstructor;
+            required: true;
+        };
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        isError: {
+            type: BooleanConstructor;
+        };
+        message: {
+            type: StringConstructor;
+            required: true;
+        };
+    }>> & Readonly<{}>, {
+        isError: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    AuthorizeForm: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        client: {
+            type: PropType<Client>;
+            required: true;
+        };
+        scopes: {
+            type: PropType<Scope[]>;
+        };
+        codeRequest: {
+            type: PropType<OAuth2AuthorizationCodeRequest>;
+            required: true;
+        };
+    }>, {
+        authorize: () => Promise<void>;
+        abort: () => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        client: {
+            type: PropType<Client>;
+            required: true;
+        };
+        scopes: {
+            type: PropType<Scope[]>;
+        };
+        codeRequest: {
+            type: PropType<OAuth2AuthorizationCodeRequest>;
+            required: true;
+        };
+    }>> & Readonly<{}>, {}, {}, {
+        AuthorizeScopes: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            client: {
+                type: PropType<Client>;
+                required: true;
+            };
+            scopesAvailable: {
+                type: PropType<Scope[]>;
+            };
+            scopesRequested: {
+                type: PropType<string[] | string>;
+            };
+        }>, {
+            scopesRequestedNormalized: import("vue").ComputedRef<string[]>;
+            scopesAvailableNormalized: import("vue").Ref<any[], any[]>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            client: {
+                type: PropType<Client>;
+                required: true;
+            };
+            scopesAvailable: {
+                type: PropType<Scope[]>;
+            };
+            scopesRequested: {
+                type: PropType<string[] | string>;
+            };
+        }>> & Readonly<{}>, {}, {}, {
+            AuthorizeScope: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                entity: {
+                    type: PropType<Scope>;
+                    required: true;
+                };
+                requested: {
+                    type: PropType<string[]>;
+                    default: () => any[];
+                };
+            }>, {
+                isEnabled: import("vue").ComputedRef<boolean>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                entity: {
+                    type: PropType<Scope>;
+                    required: true;
+                };
+                requested: {
+                    type: PropType<string[]>;
+                    default: () => any[];
+                };
+            }>> & Readonly<{}>, {
+                requested: string[];
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    Login: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        codeRequest: {
+            type: PropType<OAuth2AuthorizationCodeRequest>;
+        };
+    }>, {
+        updateRealmId: (realmId: string | string[]) => 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>;
+            };
+            password: {
+                required: import("@vuelidate/core").ValidationRuleWithoutParams<any>;
+                minLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                    min: number;
+                }, any>;
+                maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                    max: number;
+                }, any>;
+            };
+            realm_id: {};
+        }, {
+            name: string;
+            password: string;
+            realm_id: string;
+        }>, import("@vuelidate/core").Validation<{
+            name: {
+                required: import("@vuelidate/core").ValidationRuleWithoutParams<any>;
+                minLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                    min: number;
+                }, any>;
+                maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                    max: number;
+                }, any>;
+            };
+            password: {
+                required: import("@vuelidate/core").ValidationRuleWithoutParams<any>;
+                minLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                    min: number;
+                }, any>;
+                maxLength: import("@vuelidate/core").ValidationRuleWithParams<{
+                    max: number;
+                }, any>;
+            };
+            realm_id: {};
+        }, {
+            name: string;
+            password: string;
+            realm_id: string;
+        }>>;
+        form: {
+            name: string;
+            password: string;
+            realm_id: string;
+        };
+        submit: () => Promise<void>;
+        busy: import("vue").Ref<boolean, boolean>;
+        identityProviderQuery: import("vue").Ref<import("rapiq").BuildInput<import("@authup/core-kit").IdentityProvider>, import("rapiq").BuildInput<import("@authup/core-kit").IdentityProvider>>;
+        identityProviderRef: import("vue").Ref<{
+            [x: string]: any;
+            load: () => any;
+        }, {
+            [key: string]: any;
+            load: () => any;
+        } | {
+            [x: string]: any;
+            load: () => any;
+        }>;
+        buildIdentityProviderURL: (id: string) => string;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("done" | "failed")[], "done" | "failed", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        codeRequest: {
+            type: PropType<OAuth2AuthorizationCodeRequest>;
+        };
+    }>> & Readonly<{
+        onDone?: (...args: any[]) => any;
+        onFailed?: (...args: any[]) => any;
+    }>, {}, {}, {
+        ARealmPicker: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            query: {
+                type: PropType<import("rapiq").BuildInput<import("@authup/core-kit").Realm>>;
+                default(): {};
+            };
+            realmId: {
+                type: StringConstructor;
+                default: any;
+            };
+            loadOnSetup: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            loading: {
+                type: PropType<boolean | import("../../index.ts").ListLoadingOptions<import("@authup/core-kit").Realm>>;
+                default: boolean;
+            };
+            noMore: {
+                type: PropType<boolean | import("../../index.ts").ListNoMoreOptions<import("@authup/core-kit").Realm>>;
+                default: boolean;
+            };
+            footer: {
+                type: PropType<boolean | import("../../index.ts").ListFooterOptions<import("@authup/core-kit").Realm>>;
+                default: boolean;
+            };
+            header: {
+                type: PropType<boolean | import("../../index.ts").ListHeaderOptions<import("@authup/core-kit").Realm>>;
+                default: boolean;
+            };
+            body: {
+                type: PropType<import("../../index.ts").ListBodyOptions<import("@authup/core-kit").Realm>>;
+            };
+            value: {
+                type: PropType<string[] | string | null>;
+            };
+            multiple: {
+                type: PropType<boolean | undefined>;
+            };
+        }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            change: (values: string[]) => true;
+        } & import("../../index.ts").EntityCollectionVEmitOptions<import("@authup/core-kit").Realm>, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            query: {
+                type: PropType<import("rapiq").BuildInput<import("@authup/core-kit").Realm>>;
+                default(): {};
+            };
+            realmId: {
+                type: StringConstructor;
+                default: any;
+            };
+            loadOnSetup: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            loading: {
+                type: PropType<boolean | import("../../index.ts").ListLoadingOptions<import("@authup/core-kit").Realm>>;
+                default: boolean;
+            };
+            noMore: {
+                type: PropType<boolean | import("../../index.ts").ListNoMoreOptions<import("@authup/core-kit").Realm>>;
+                default: boolean;
+            };
+            footer: {
+                type: PropType<boolean | import("../../index.ts").ListFooterOptions<import("@authup/core-kit").Realm>>;
+                default: boolean;
+            };
+            header: {
+                type: PropType<boolean | import("../../index.ts").ListHeaderOptions<import("@authup/core-kit").Realm>>;
+                default: boolean;
+            };
+            body: {
+                type: PropType<import("../../index.ts").ListBodyOptions<import("@authup/core-kit").Realm>>;
+            };
+            value: {
+                type: PropType<string[] | string | null>;
+            };
+            multiple: {
+                type: PropType<boolean | undefined>;
+            };
+        }>> & Readonly<{
+            onUpdated?: (item: import("@authup/core-kit").Realm) => any;
+            onDeleted?: (item: import("@authup/core-kit").Realm) => any;
+            onCreated?: (item: import("@authup/core-kit").Realm) => any;
+            onChange?: (values: string[]) => any;
+        }>, {
+            footer: boolean;
+            header: boolean;
+            query: import("rapiq").BuildInput<import("@authup/core-kit").Realm>;
+            realmId: string;
+            loadOnSetup: boolean;
+            loading: boolean;
+            noMore: boolean;
+        }, import("vue").SlotsType<import("../../index.ts").EntityPickerVSlots<import("@authup/core-kit").Realm>>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        APagination: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            total: {
+                type: NumberConstructor;
+            };
+            meta: {
+                type: PropType<Record<string, any>>;
+            };
+            busy: {
+                type: BooleanConstructor;
+            };
+            load: {
+                type: PropType<import("../../utility/pagination/type.ts").PaginationLoadFn>;
+                required: true;
+            };
+        }>, () => VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            total: {
+                type: NumberConstructor;
+            };
+            meta: {
+                type: PropType<Record<string, any>>;
+            };
+            busy: {
+                type: BooleanConstructor;
+            };
+            load: {
+                type: PropType<import("../../utility/pagination/type.ts").PaginationLoadFn>;
+                required: true;
+            };
+        }>> & Readonly<{}>, {
+            busy: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        ATitle: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            icon: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            iconPosition: {
+                type: PropType<"start" | "end">;
+            };
+            iconClass: {
+                type: StringConstructor;
+            };
+            text: {
+                type: StringConstructor;
+            };
+        }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: 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<{
+            icon: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            iconPosition: {
+                type: PropType<"start" | "end">;
+            };
+            iconClass: {
+                type: StringConstructor;
+            };
+            text: {
+                type: StringConstructor;
+            };
+        }>> & Readonly<{}>, {
+            icon: boolean;
+        }, import("vue").SlotsType<{
+            default: import("../../utility/title/type.ts").TitleSlotProps;
+        }>, {}, {}, 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>;
+        AIdentityProviders: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            query: {
+                type: PropType<import("rapiq").BuildInput<import("@authup/core-kit").IdentityProvider>>;
+                default(): {};
+            };
+            realmId: {
+                type: StringConstructor;
+                default: any;
+            };
+            loadOnSetup: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            loading: {
+                type: PropType<boolean | import("../../index.ts").ListLoadingOptions<import("@authup/core-kit").IdentityProvider>>;
+                default: boolean;
+            };
+            noMore: {
+                type: PropType<boolean | import("../../index.ts").ListNoMoreOptions<import("@authup/core-kit").IdentityProvider>>;
+                default: boolean;
+            };
+            footer: {
+                type: PropType<boolean | import("../../index.ts").ListFooterOptions<import("@authup/core-kit").IdentityProvider>>;
+                default: boolean;
+            };
+            header: {
+                type: PropType<boolean | import("../../index.ts").ListHeaderOptions<import("@authup/core-kit").IdentityProvider>>;
+                default: boolean;
+            };
+            body: {
+                type: PropType<import("../../index.ts").ListBodyOptions<import("@authup/core-kit").IdentityProvider>>;
+            };
+        }>, () => VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("../../index.ts").EntityCollectionVEmitOptions<import("@authup/core-kit").IdentityProvider>, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            query: {
+                type: PropType<import("rapiq").BuildInput<import("@authup/core-kit").IdentityProvider>>;
+                default(): {};
+            };
+            realmId: {
+                type: StringConstructor;
+                default: any;
+            };
+            loadOnSetup: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            loading: {
+                type: PropType<boolean | import("../../index.ts").ListLoadingOptions<import("@authup/core-kit").IdentityProvider>>;
+                default: boolean;
+            };
+            noMore: {
+                type: PropType<boolean | import("../../index.ts").ListNoMoreOptions<import("@authup/core-kit").IdentityProvider>>;
+                default: boolean;
+            };
+            footer: {
+                type: PropType<boolean | import("../../index.ts").ListFooterOptions<import("@authup/core-kit").IdentityProvider>>;
+                default: boolean;
+            };
+            header: {
+                type: PropType<boolean | import("../../index.ts").ListHeaderOptions<import("@authup/core-kit").IdentityProvider>>;
+                default: boolean;
+            };
+            body: {
+                type: PropType<import("../../index.ts").ListBodyOptions<import("@authup/core-kit").IdentityProvider>>;
+            };
+        }>> & Readonly<{
+            onUpdated?: (item: import("@authup/core-kit").IdentityProvider) => any;
+            onDeleted?: (item: import("@authup/core-kit").IdentityProvider) => any;
+            onCreated?: (item: import("@authup/core-kit").IdentityProvider) => any;
+        }>, {
+            footer: boolean;
+            header: boolean;
+            query: import("rapiq").BuildInput<import("@authup/core-kit").IdentityProvider>;
+            realmId: string;
+            loadOnSetup: boolean;
+            loading: boolean;
+            noMore: boolean;
+        }, import("vue").SlotsType<import("../../index.ts").EntityCollectionVSlots<import("@authup/core-kit").IdentityProvider>>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        AIdentityProviderIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            entity: {
+                type: PropType<import("@authup/core-kit").IdentityProvider>;
+                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<{
+            entity: {
+                type: PropType<import("@authup/core-kit").IdentityProvider>;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=Authorize.vue.d.ts.map

package/dist/components/workflows/authorize/Authorize.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Authorize.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/workflows/authorize/Authorize.vue"],"names":[],"mappings":"AAqJA,OAAO,KAAK,EACR,MAAM,EAAE,8BAA8B,EAAE,KAAK,EAChD,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;wBAuB3B,OAAO,YAAY;AAAxC,wBAAyC;AAazC,QAAA,MAAM,YAAY;;cAQU,QAAQ,CAAC,8BAA8B,CAAC;;;cAGxC,QAAQ,CAAC,MAAM,CAAC;;;;;;cAMjB,QAAQ,CAAC,KAAK,EAAE,CAAC;;;cAGhB,QAAQ,CAAC,KAAK,CAAC;;;;;;cAZf,QAAQ,CAAC,8BAA8B,CAAC;;;cAGxC,QAAQ,CAAC,MAAM,CAAC;;;;;;cAMjB,QAAQ,CAAC,KAAK,EAAE,CAAC;;;cAGhB,QAAQ,CAAC,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEA2EzC,CAAC"}

package/dist/components/workflows/authorize/AuthorizeForm.vue.d.ts

@@ -0,0 +1,84 @@
+import type { Client, OAuth2AuthorizationCodeRequest, Scope } from '@authup/core-kit';
+import type { PropType } from 'vue';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    client: {
+        type: PropType<Client>;
+        required: true;
+    };
+    scopes: {
+        type: PropType<Scope[]>;
+    };
+    codeRequest: {
+        type: PropType<OAuth2AuthorizationCodeRequest>;
+        required: true;
+    };
+}>, {
+    authorize: () => Promise<void>;
+    abort: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    client: {
+        type: PropType<Client>;
+        required: true;
+    };
+    scopes: {
+        type: PropType<Scope[]>;
+    };
+    codeRequest: {
+        type: PropType<OAuth2AuthorizationCodeRequest>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {
+    AuthorizeScopes: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        client: {
+            type: PropType<Client>;
+            required: true;
+        };
+        scopesAvailable: {
+            type: PropType<Scope[]>;
+        };
+        scopesRequested: {
+            type: PropType<string[] | string>;
+        };
+    }>, {
+        scopesRequestedNormalized: import("vue").ComputedRef<string[]>;
+        scopesAvailableNormalized: import("vue").Ref<any[], any[]>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        client: {
+            type: PropType<Client>;
+            required: true;
+        };
+        scopesAvailable: {
+            type: PropType<Scope[]>;
+        };
+        scopesRequested: {
+            type: PropType<string[] | string>;
+        };
+    }>> & Readonly<{}>, {}, {}, {
+        AuthorizeScope: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            entity: {
+                type: PropType<Scope>;
+                required: true;
+            };
+            requested: {
+                type: PropType<string[]>;
+                default: () => any[];
+            };
+        }>, {
+            isEnabled: import("vue").ComputedRef<boolean>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            entity: {
+                type: PropType<Scope>;
+                required: true;
+            };
+            requested: {
+                type: PropType<string[]>;
+                default: () => any[];
+            };
+        }>> & Readonly<{}>, {
+            requested: string[];
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=AuthorizeForm.vue.d.ts.map

package/dist/components/workflows/authorize/AuthorizeForm.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthorizeForm.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/workflows/authorize/AuthorizeForm.vue"],"names":[],"mappings":"AA6JA,OAAO,KAAK,EAAE,MAAM,EAAE,8BAA8B,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACtF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;wBAKf,OAAO,YAAY;AAAxC,wBAAyC;AA8IzC,QAAA,MAAM,YAAY;;cAIU,QAAQ,CAAC,MAAM,CAAC;;;;cAIjB,QAAQ,CAAC,KAAK,EAAE,CAAC;;;cAGhB,QAAQ,CAAC,8BAA8B,CAAC;;;;;;;;cAPxC,QAAQ,CAAC,MAAM,CAAC;;;;cAIjB,QAAQ,CAAC,KAAK,EAAE,CAAC;;;cAGhB,QAAQ,CAAC,8BAA8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEAoDlE,CAAC"}

package/dist/components/workflows/authorize/AuthorizeScope.vue.d.ts

@@ -0,0 +1,28 @@
+import type { Scope } from '@authup/core-kit';
+import type { PropType } from 'vue';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<Scope>;
+        required: true;
+    };
+    requested: {
+        type: PropType<string[]>;
+        default: () => any[];
+    };
+}>, {
+    isEnabled: import("vue").ComputedRef<boolean>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<Scope>;
+        required: true;
+    };
+    requested: {
+        type: PropType<string[]>;
+        default: () => any[];
+    };
+}>> & Readonly<{}>, {
+    requested: string[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=AuthorizeScope.vue.d.ts.map

package/dist/components/workflows/authorize/AuthorizeScope.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthorizeScope.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/workflows/authorize/AuthorizeScope.vue"],"names":[],"mappings":"AAsDA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;wBAGf,OAAO,YAAY;AAAxC,wBAAyC;AAwCzC,QAAA,MAAM,YAAY;;cAGU,QAAQ,CAAC,KAAK,CAAC;;;;cAIhB,QAAQ,CAAC,MAAM,EAAE,CAAC;;;;;;;cAJjB,QAAQ,CAAC,KAAK,CAAC;;;;cAIhB,QAAQ,CAAC,MAAM,EAAE,CAAC;;;;;4EAW3C,CAAC"}

package/dist/components/workflows/authorize/AuthorizeScopes.vue.d.ts

@@ -0,0 +1,55 @@
+import type { Client, Scope } from '@authup/core-kit';
+import type { PropType } from 'vue';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    client: {
+        type: PropType<Client>;
+        required: true;
+    };
+    scopesAvailable: {
+        type: PropType<Scope[]>;
+    };
+    scopesRequested: {
+        type: PropType<string[] | string>;
+    };
+}>, {
+    scopesRequestedNormalized: import("vue").ComputedRef<string[]>;
+    scopesAvailableNormalized: import("vue").Ref<any[], any[]>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    client: {
+        type: PropType<Client>;
+        required: true;
+    };
+    scopesAvailable: {
+        type: PropType<Scope[]>;
+    };
+    scopesRequested: {
+        type: PropType<string[] | string>;
+    };
+}>> & Readonly<{}>, {}, {}, {
+    AuthorizeScope: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        entity: {
+            type: PropType<Scope>;
+            required: true;
+        };
+        requested: {
+            type: PropType<string[]>;
+            default: () => any[];
+        };
+    }>, {
+        isEnabled: import("vue").ComputedRef<boolean>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        entity: {
+            type: PropType<Scope>;
+            required: true;
+        };
+        requested: {
+            type: PropType<string[]>;
+            default: () => any[];
+        };
+    }>> & Readonly<{}>, {
+        requested: string[];
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=AuthorizeScopes.vue.d.ts.map

package/dist/components/workflows/authorize/AuthorizeScopes.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthorizeScopes.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/workflows/authorize/AuthorizeScopes.vue"],"names":[],"mappings":"AA6FA,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;wBAKf,OAAO,YAAY;AAAxC,wBAAyC;AAiDzC,QAAA,MAAM,YAAY;;cAIU,QAAQ,CAAC,MAAM,CAAC;;;;cAIjB,QAAQ,CAAC,KAAK,EAAE,CAAC;;;cAGP,QAAQ,CAAC,MAAM,EAAE,GAAG,MAAM,CAAC;;;;;;;cAPpC,QAAQ,CAAC,MAAM,CAAC;;;;cAIjB,QAAQ,CAAC,KAAK,EAAE,CAAC;;;cAGP,QAAQ,CAAC,MAAM,EAAE,GAAG,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;oEA4C9D,CAAC"}