@authup/client-web-kit 1.0.0-beta.10

package/dist/components/client-scope/AClientScopes.d.ts

@@ -0,0 +1,82 @@
+import type { SlotsType } from 'vue';
+import type { ClientScope } from '@authup/core-kit';
+import type { ListSlotsType } from '../../core';
+export declare const AClientScopes: import("vue").DefineComponent<{
+    query: {
+        type: import("vue").PropType<import("rapiq").BuildInput<ClientScope>>;
+        default(): {};
+    };
+    realmId: {
+        type: StringConstructor;
+        default: any;
+    };
+    loadOnSetup: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: import("vue").PropType<boolean | import("../../core").ListLoadingOptions<ClientScope>>;
+        default: boolean;
+    };
+    noMore: {
+        type: import("vue").PropType<boolean | import("../../core").ListNoMoreOptions<ClientScope>>;
+        default: boolean;
+    };
+    footer: {
+        type: import("vue").PropType<boolean | import("../../core").ListFooterOptions<ClientScope>>;
+        default: boolean;
+    };
+    header: {
+        type: import("vue").PropType<boolean | import("../../core").ListHeaderOptions<ClientScope>>;
+        default: boolean;
+    };
+    body: {
+        type: import("vue").PropType<import("../../core").ListBodyOptions<ClientScope>>;
+    };
+}, () => import("vue").VNodeChild, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("../../core").ListEventsType<ClientScope>, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    query: {
+        type: import("vue").PropType<import("rapiq").BuildInput<ClientScope>>;
+        default(): {};
+    };
+    realmId: {
+        type: StringConstructor;
+        default: any;
+    };
+    loadOnSetup: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: import("vue").PropType<boolean | import("../../core").ListLoadingOptions<ClientScope>>;
+        default: boolean;
+    };
+    noMore: {
+        type: import("vue").PropType<boolean | import("../../core").ListNoMoreOptions<ClientScope>>;
+        default: boolean;
+    };
+    footer: {
+        type: import("vue").PropType<boolean | import("../../core").ListFooterOptions<ClientScope>>;
+        default: boolean;
+    };
+    header: {
+        type: import("vue").PropType<boolean | import("../../core").ListHeaderOptions<ClientScope>>;
+        default: boolean;
+    };
+    body: {
+        type: import("vue").PropType<import("../../core").ListBodyOptions<ClientScope>>;
+    };
+}>> & {
+    onCreated?: (item: ClientScope) => any;
+    onUpdated?: (item: ClientScope) => any;
+    onDeleted?: (item: ClientScope) => any;
+}, {
+    footer: boolean;
+    header: boolean;
+    realmId: string;
+    noMore: boolean;
+    loading: boolean;
+    query: {};
+    loadOnSetup: boolean;
+}, SlotsType<ListSlotsType<ClientScope>>>;
+export default AClientScopes;
+//# sourceMappingURL=AClientScopes.d.ts.map

package/dist/components/client-scope/AClientScopes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AClientScopes.d.ts","sourceRoot":"","sources":["../../../src/components/client-scope/AClientScopes.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AAErC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAWhD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAgCxB,CAAC;AAEH,eAAe,aAAa,CAAC"}

package/dist/components/client-scope/index.d.ts

@@ -0,0 +1,5 @@
+export { AClientScope } from './AClientScope';
+export { AClientScopes } from './AClientScopes';
+export { AClientScopeAssignments } from './AClientScopeAssignments';
+export { AClientScopeAssignment } from './AClientScopeAssignment';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/client-scope/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/client-scope/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/components/identity-provider/AIdentityProvider.d.ts

@@ -0,0 +1,43 @@
+import type { IdentityProvider } from '@authup/core-kit';
+import type { SlotsType } from 'vue';
+import type { EntityManagerSlotsType } from '../../core';
+export declare const AIdentityProvider: import("vue").DefineComponent<{
+    entity: {
+        type: import("vue").PropType<IdentityProvider>;
+    };
+    entityId: {
+        type: StringConstructor;
+    };
+    queryFilters: {
+        type: import("vue").PropType<import("rapiq").FiltersBuildInput<IdentityProvider>>;
+    };
+    queryFields: {
+        type: import("vue").PropType<import("rapiq").FieldsBuildInput<IdentityProvider>>;
+    };
+    query: {
+        type: import("vue").PropType<import("rapiq").BuildInput<IdentityProvider>>;
+    };
+}, () => import("vue").VNodeChild, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("../../core").EntityManagerEventsType<IdentityProvider>, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: import("vue").PropType<IdentityProvider>;
+    };
+    entityId: {
+        type: StringConstructor;
+    };
+    queryFilters: {
+        type: import("vue").PropType<import("rapiq").FiltersBuildInput<IdentityProvider>>;
+    };
+    queryFields: {
+        type: import("vue").PropType<import("rapiq").FieldsBuildInput<IdentityProvider>>;
+    };
+    query: {
+        type: import("vue").PropType<import("rapiq").BuildInput<IdentityProvider>>;
+    };
+}>> & {
+    onCreated?: (item: IdentityProvider) => any;
+    onUpdated?: (item: IdentityProvider) => any;
+    onDeleted?: (item: IdentityProvider) => any;
+    onFailed?: (item: Error) => any;
+    onResolved?: (_item?: IdentityProvider) => any;
+}, {}, SlotsType<EntityManagerSlotsType<IdentityProvider>>>;
+//# sourceMappingURL=AIdentityProvider.d.ts.map

package/dist/components/identity-provider/AIdentityProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIdentityProvider.d.ts","sourceRoot":"","sources":["../../../src/components/identity-provider/AIdentityProvider.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AAErC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAOzD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DAmB5B,CAAC"}

package/dist/components/identity-provider/AIdentityProviderBasicFields.d.ts

@@ -0,0 +1,14 @@
+import type { IdentityProvider } from '@authup/core-kit';
+import type { PropType } from 'vue';
+export declare const AIdentityProviderBasicFields: import("vue").DefineComponent<{
+    entity: {
+        type: PropType<Partial<IdentityProvider>>;
+    };
+}, () => import("vue").VNodeChild[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "updated"[], "updated", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<Partial<IdentityProvider>>;
+    };
+}>> & {
+    onUpdated?: (...args: any[]) => any;
+}, {}, {}>;
+//# sourceMappingURL=AIdentityProviderBasicFields.d.ts.map

package/dist/components/identity-provider/AIdentityProviderBasicFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIdentityProviderBasicFields.d.ts","sourceRoot":"","sources":["../../../src/components/identity-provider/AIdentityProviderBasicFields.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAOzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAYpC,eAAO,MAAM,4BAA4B;;;;;;;;;;UAwIvC,CAAC"}

package/dist/components/identity-provider/AIdentityProviderForm.d.ts

@@ -0,0 +1,33 @@
+import type { IdentityProvider } from '@authup/core-kit';
+import type { PropType, VNodeChild } from 'vue';
+export declare const AIdentityProviderForm: import("vue").DefineComponent<{
+    entity: {
+        type: PropType<IdentityProvider>;
+    };
+    realmId: {
+        type: StringConstructor;
+    };
+    apiUrl: {
+        type: StringConstructor;
+        default: string;
+    };
+}, () => VNodeChild, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("created" | "updated" | "deleted" | "failed")[], "created" | "updated" | "deleted" | "failed", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<IdentityProvider>;
+    };
+    realmId: {
+        type: StringConstructor;
+    };
+    apiUrl: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & {
+    onCreated?: (...args: any[]) => any;
+    onUpdated?: (...args: any[]) => any;
+    onDeleted?: (...args: any[]) => any;
+    onFailed?: (...args: any[]) => any;
+}, {
+    apiUrl: string;
+}, {}>;
+//# sourceMappingURL=AIdentityProviderForm.d.ts.map

package/dist/components/identity-provider/AIdentityProviderForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIdentityProviderForm.d.ts","sourceRoot":"","sources":["../../../src/components/identity-provider/AIdentityProviderForm.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,gBAAgB,EAA0B,MAAM,kBAAkB,CAAC;AACjF,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AAMhD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA4HhC,CAAC"}

package/dist/components/identity-provider/AIdentityProviderIcon.d.ts

@@ -0,0 +1,16 @@
+import type { IdentityProvider } from '@authup/core-kit';
+import type { PropType } from 'vue';
+export declare const AIdentityProviderIcon: import("vue").DefineComponent<{
+    entity: {
+        type: PropType<IdentityProvider>;
+        required: true;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<IdentityProvider>;
+        required: true;
+    };
+}>>, {}, {}>;
+//# sourceMappingURL=AIdentityProviderIcon.d.ts.map

package/dist/components/identity-provider/AIdentityProviderIcon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIdentityProviderIcon.d.ts","sourceRoot":"","sources":["../../../src/components/identity-provider/AIdentityProviderIcon.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAOpC,eAAO,MAAM,qBAAqB;;;;;;;;;;;;YAsBhC,CAAC"}

package/dist/components/identity-provider/AIdentityProviderLdapConnectionFields.d.ts

@@ -0,0 +1,26 @@
+import type { LdapIdentityProvider } from '@authup/core-kit';
+import type { PropType } from 'vue';
+export declare const AIdentityProviderLdapConnectionFields: import("vue").DefineComponent<{
+    entity: {
+        type: PropType<Partial<LdapIdentityProvider>>;
+    };
+    discovery: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "updated"[], "updated", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<Partial<LdapIdentityProvider>>;
+    };
+    discovery: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onUpdated?: (...args: any[]) => any;
+}, {
+    discovery: boolean;
+}, {}>;
+//# sourceMappingURL=AIdentityProviderLdapConnectionFields.d.ts.map

package/dist/components/identity-provider/AIdentityProviderLdapConnectionFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIdentityProviderLdapConnectionFields.d.ts","sourceRoot":"","sources":["../../../src/components/identity-provider/AIdentityProviderLdapConnectionFields.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACU,oBAAoB,EACzC,MAAM,kBAAkB,CAAC;AAM1B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAOpC,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;MAkHhD,CAAC"}

package/dist/components/identity-provider/AIdentityProviderLdapCredentialsFields.d.ts

@@ -0,0 +1,26 @@
+import type { LdapIdentityProvider } from '@authup/core-kit';
+import type { PropType } from 'vue';
+export declare const AIdentityProviderLdapCredentialsFields: import("vue").DefineComponent<{
+    entity: {
+        type: PropType<Partial<LdapIdentityProvider>>;
+    };
+    discovery: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "updated"[], "updated", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<Partial<LdapIdentityProvider>>;
+    };
+    discovery: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onUpdated?: (...args: any[]) => any;
+}, {
+    discovery: boolean;
+}, {}>;
+//# sourceMappingURL=AIdentityProviderLdapCredentialsFields.d.ts.map

package/dist/components/identity-provider/AIdentityProviderLdapCredentialsFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIdentityProviderLdapCredentialsFields.d.ts","sourceRoot":"","sources":["../../../src/components/identity-provider/AIdentityProviderLdapCredentialsFields.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACU,oBAAoB,EACzC,MAAM,kBAAkB,CAAC;AAI1B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAOpC,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;MAoEjD,CAAC"}

package/dist/components/identity-provider/AIdentityProviderLdapForm.d.ts

@@ -0,0 +1,35 @@
+import type { IdentityProvider } from '@authup/core-kit';
+import { type PropType } from 'vue';
+export declare const AIdentityProviderLdapForm: import("vue").DefineComponent<{
+    entity: {
+        type: PropType<IdentityProvider>;
+        required: false;
+        default: any;
+    };
+    realmId: {
+        type: StringConstructor;
+        default: any;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("../../core").EntityManagerEventsType<IdentityProvider>, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<IdentityProvider>;
+        required: false;
+        default: any;
+    };
+    realmId: {
+        type: StringConstructor;
+        default: any;
+    };
+}>> & {
+    onCreated?: (item: IdentityProvider) => any;
+    onUpdated?: (item: IdentityProvider) => any;
+    onDeleted?: (item: IdentityProvider) => any;
+    onFailed?: (item: Error) => any;
+    onResolved?: (_item?: IdentityProvider) => any;
+}, {
+    realmId: string;
+    entity: IdentityProvider;
+}, {}>;
+//# sourceMappingURL=AIdentityProviderLdapForm.d.ts.map

package/dist/components/identity-provider/AIdentityProviderLdapForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIdentityProviderLdapForm.d.ts","sourceRoot":"","sources":["../../../src/components/identity-provider/AIdentityProviderLdapForm.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,gBAAgB,EAAwB,MAAM,kBAAkB,CAAC;AAG/E,OAAO,EACH,KAAK,QAAQ,EAChB,MAAM,KAAK,CAAC;AAiBb,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAqKpC,CAAC"}

package/dist/components/identity-provider/AIdentityProviderLdapGroupFields.d.ts

@@ -0,0 +1,26 @@
+import type { LdapIdentityProvider } from '@authup/core-kit';
+import type { PropType } from 'vue';
+export declare const AIdentityProviderLdapGroupFields: import("vue").DefineComponent<{
+    entity: {
+        type: PropType<Partial<LdapIdentityProvider>>;
+    };
+    discovery: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "updated"[], "updated", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<Partial<LdapIdentityProvider>>;
+    };
+    discovery: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onUpdated?: (...args: any[]) => any;
+}, {
+    discovery: boolean;
+}, {}>;
+//# sourceMappingURL=AIdentityProviderLdapGroupFields.d.ts.map

package/dist/components/identity-provider/AIdentityProviderLdapGroupFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIdentityProviderLdapGroupFields.d.ts","sourceRoot":"","sources":["../../../src/components/identity-provider/AIdentityProviderLdapGroupFields.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACU,oBAAoB,EACzC,MAAM,kBAAkB,CAAC;AAG1B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAOpC,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;MA2H3C,CAAC"}

package/dist/components/identity-provider/AIdentityProviderLdapUserFields.d.ts

@@ -0,0 +1,26 @@
+import type { LdapIdentityProvider } from '@authup/core-kit';
+import type { PropType } from 'vue';
+export declare const AIdentityProviderLdapUserFields: import("vue").DefineComponent<{
+    entity: {
+        type: PropType<Partial<LdapIdentityProvider>>;
+    };
+    discovery: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "updated"[], "updated", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<Partial<LdapIdentityProvider>>;
+    };
+    discovery: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onUpdated?: (...args: any[]) => any;
+}, {
+    discovery: boolean;
+}, {}>;
+//# sourceMappingURL=AIdentityProviderLdapUserFields.d.ts.map

package/dist/components/identity-provider/AIdentityProviderLdapUserFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIdentityProviderLdapUserFields.d.ts","sourceRoot":"","sources":["../../../src/components/identity-provider/AIdentityProviderLdapUserFields.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACU,oBAAoB,EACzC,MAAM,kBAAkB,CAAC;AAG1B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAOpC,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;MA6G1C,CAAC"}

package/dist/components/identity-provider/AIdentityProviderOAuth2ClientFields.d.ts

@@ -0,0 +1,16 @@
+import type { OAuth2IdentityProvider } from '@authup/core-kit';
+import type { PropType } from 'vue';
+export declare const AIdentityProviderOAuth2ClientFields: import("vue").DefineComponent<{
+    entity: {
+        type: PropType<Partial<OAuth2IdentityProvider>>;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "updated"[], "updated", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<Partial<OAuth2IdentityProvider>>;
+    };
+}>> & {
+    onUpdated?: (...args: any[]) => any;
+}, {}, {}>;
+//# sourceMappingURL=AIdentityProviderOAuth2ClientFields.d.ts.map

package/dist/components/identity-provider/AIdentityProviderOAuth2ClientFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIdentityProviderOAuth2ClientFields.d.ts","sourceRoot":"","sources":["../../../src/components/identity-provider/AIdentityProviderOAuth2ClientFields.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAoB,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAMjF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAOpC,eAAO,MAAM,mCAAmC;;;;;;;;;;;;UAiE9C,CAAC"}

package/dist/components/identity-provider/AIdentityProviderOAuth2Discovery.d.ts

@@ -0,0 +1,6 @@
+import type { VNodeChild } from 'vue';
+export declare const AIdentityProviderOAuth2Discovery: import("vue").DefineComponent<{}, () => VNodeChild[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("failed" | "lookup")[], "failed" | "lookup", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>> & {
+    onFailed?: (...args: any[]) => any;
+    onLookup?: (...args: any[]) => any;
+}, {}, {}>;
+//# sourceMappingURL=AIdentityProviderOAuth2Discovery.d.ts.map

package/dist/components/identity-provider/AIdentityProviderOAuth2Discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIdentityProviderOAuth2Discovery.d.ts","sourceRoot":"","sources":["../../../src/components/identity-provider/AIdentityProviderOAuth2Discovery.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AAMtC,eAAO,MAAM,gCAAgC;;;UAwF3C,CAAC"}

package/dist/components/identity-provider/AIdentityProviderOAuth2EndpointFields.d.ts

@@ -0,0 +1,24 @@
+import type { OAuth2IdentityProvider } from '@authup/core-kit';
+import type { PropType, VNodeChild } from 'vue';
+export declare const AIdentityProviderOAuth2EndpointFields: import("vue").DefineComponent<{
+    entity: {
+        type: PropType<Partial<OAuth2IdentityProvider>>;
+    };
+    discovery: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, () => VNodeChild[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "updated"[], "updated", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<Partial<OAuth2IdentityProvider>>;
+    };
+    discovery: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onUpdated?: (...args: any[]) => any;
+}, {
+    discovery: boolean;
+}, {}>;
+//# sourceMappingURL=AIdentityProviderOAuth2EndpointFields.d.ts.map

package/dist/components/identity-provider/AIdentityProviderOAuth2EndpointFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIdentityProviderOAuth2EndpointFields.d.ts","sourceRoot":"","sources":["../../../src/components/identity-provider/AIdentityProviderOAuth2EndpointFields.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAoB,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAOjF,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AAQhD,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;MA+GhD,CAAC"}

package/dist/components/identity-provider/AIdentityProviderOAuth2Form.d.ts

@@ -0,0 +1,61 @@
+import type { PropType } from 'vue';
+import type { IdentityProvider } from '@authup/core-kit';
+import { IdentityProviderProtocol } from '@authup/core-kit';
+export declare const AIdentityProviderOAuth2Form: import("vue").DefineComponent<{
+    entity: {
+        type: PropType<IdentityProvider>;
+        required: false;
+        default: any;
+    };
+    realmId: {
+        type: StringConstructor;
+        default: any;
+    };
+    apiUrl: {
+        type: StringConstructor;
+        default: string;
+    };
+    protocol: {
+        type: PropType<string>;
+        default: IdentityProviderProtocol;
+    };
+    preset: {
+        type: PropType<string>;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("../../core").EntityManagerEventsType<IdentityProvider>, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    entity: {
+        type: PropType<IdentityProvider>;
+        required: false;
+        default: any;
+    };
+    realmId: {
+        type: StringConstructor;
+        default: any;
+    };
+    apiUrl: {
+        type: StringConstructor;
+        default: string;
+    };
+    protocol: {
+        type: PropType<string>;
+        default: IdentityProviderProtocol;
+    };
+    preset: {
+        type: PropType<string>;
+    };
+}>> & {
+    onCreated?: (item: IdentityProvider) => any;
+    onUpdated?: (item: IdentityProvider) => any;
+    onDeleted?: (item: IdentityProvider) => any;
+    onFailed?: (item: Error) => any;
+    onResolved?: (_item?: IdentityProvider) => any;
+}, {
+    realmId: string;
+    entity: IdentityProvider;
+    protocol: string;
+    apiUrl: string;
+}, {}>;
+export default AIdentityProviderOAuth2Form;
+//# sourceMappingURL=AIdentityProviderOAuth2Form.d.ts.map

package/dist/components/identity-provider/AIdentityProviderOAuth2Form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIdentityProviderOAuth2Form.d.ts","sourceRoot":"","sources":["../../../src/components/identity-provider/AIdentityProviderOAuth2Form.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACR,QAAQ,EAEX,MAAM,KAAK,CAAC;AAOb,OAAO,KAAK,EACR,gBAAgB,EAEnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACS,wBAAwB,EACvC,MAAM,kBAAkB,CAAC;AAoB1B,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAkQtC,CAAC;AAEH,eAAe,2BAA2B,CAAC"}

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

@@ -0,0 +1,18 @@
+export declare const AIdentityProviderPicker: import("vue").DefineComponent<{
+    protocol: {
+        type: StringConstructor;
+    };
+    preset: {
+        type: StringConstructor;
+    };
+}, () => import("vue").VNodeChild[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "pick"[], "pick", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    protocol: {
+        type: StringConstructor;
+    };
+    preset: {
+        type: StringConstructor;
+    };
+}>> & {
+    onPick?: (...args: any[]) => any;
+}, {}, {}>;
+//# sourceMappingURL=AIdentityProviderPicker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AIdentityProviderPicker.d.ts","sourceRoot":"","sources":["../../../src/components/identity-provider/AIdentityProviderPicker.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;UAoGlC,CAAC"}

package/dist/components/identity-provider/AIdentityProviderPreset.d.ts

@@ -0,0 +1,16 @@
+export declare const AIdentityProviderPreset: import("vue").DefineComponent<{
+    id: {
+        type: StringConstructor;
+        required: true;
+    };
+}, (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[]) | (() => any[]), unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+        required: true;
+    };
+}>>, {}, {}>;
+//# sourceMappingURL=AIdentityProviderPreset.d.ts.map

package/dist/components/identity-provider/AIdentityProviderPreset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIdentityProviderPreset.d.ts","sourceRoot":"","sources":["../../../src/components/identity-provider/AIdentityProviderPreset.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;YAmBlC,CAAC"}

package/dist/components/identity-provider/AIdentityProviderProtocol.d.ts

@@ -0,0 +1,16 @@
+export declare const AIdentityProviderProtocol: import("vue").DefineComponent<{
+    id: {
+        type: StringConstructor;
+        required: true;
+    };
+}, (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[]) | (() => any[]), unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+        required: true;
+    };
+}>>, {}, {}>;
+//# sourceMappingURL=AIdentityProviderProtocol.d.ts.map

package/dist/components/identity-provider/AIdentityProviderProtocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIdentityProviderProtocol.d.ts","sourceRoot":"","sources":["../../../src/components/identity-provider/AIdentityProviderProtocol.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;YAmBpC,CAAC"}