@estifanos-sh/convex-auth 0.0.2 → 0.0.3

package/dist/component/connection/domain/verification.d.ts

@@ -1,5 +1,5 @@
-import * as convex_values2797 from "convex/values";
-import * as convex_server193 from "convex/server";
+import * as convex_values2293 from "convex/values";
+import * as convex_server190 from "convex/server";
 
 //#region src/component/connection/domain/verification.d.ts
 declare namespace verification_d_exports {
@@ -12,36 +12,36 @@ declare namespace verification_d_exports {
  * @module
  */
 /** Read a domain's verification record by `domainId`, or `null` if none. */
-declare const get: convex_server193.RegisteredQuery<"public", {
-  domainId: convex_values2797.GenericId<"GroupConnectionDomain">;
+declare const get: convex_server190.RegisteredQuery<"public", {
+  domainId: convex_values2293.GenericId<"GroupConnectionDomain">;
 }, Promise<{
-  _id: convex_values2797.GenericId<"GroupConnectionDomainVerification">;
+  _id: convex_values2293.GenericId<"GroupConnectionDomainVerification">;
   _creationTime: number;
-  connectionId: convex_values2797.GenericId<"GroupConnection">;
-  expiresAt: number;
-  groupId: convex_values2797.GenericId<"Group">;
-  tokenHash: string;
+  connectionId: convex_values2293.GenericId<"GroupConnection">;
   domain: string;
-  domainId: convex_values2797.GenericId<"GroupConnectionDomain">;
   recordName: string;
+  expiresAt: number;
+  groupId: convex_values2293.GenericId<"Group">;
+  tokenHash: string;
+  domainId: convex_values2293.GenericId<"GroupConnectionDomain">;
   token: string;
   requestedAt: number;
 } | null>>;
 /** Insert a verification record, or patch it when one already exists for the domain (keyed by `domainId`). */
-declare const upsert: convex_server193.RegisteredMutation<"public", {
-  connectionId: convex_values2797.GenericId<"GroupConnection">;
-  expiresAt: number;
-  groupId: convex_values2797.GenericId<"Group">;
-  tokenHash: string;
+declare const upsert: convex_server190.RegisteredMutation<"public", {
+  connectionId: convex_values2293.GenericId<"GroupConnection">;
   domain: string;
-  domainId: convex_values2797.GenericId<"GroupConnectionDomain">;
   recordName: string;
+  expiresAt: number;
+  groupId: convex_values2293.GenericId<"Group">;
+  tokenHash: string;
+  domainId: convex_values2293.GenericId<"GroupConnectionDomain">;
   token: string;
   requestedAt: number;
-}, Promise<convex_values2797.GenericId<"GroupConnectionDomainVerification">>>;
+}, Promise<convex_values2293.GenericId<"GroupConnectionDomainVerification">>>;
 /** Delete a domain's verification record, if any. */
-declare const remove: convex_server193.RegisteredMutation<"public", {
-  domainId: convex_values2797.GenericId<"GroupConnectionDomain">;
+declare const remove: convex_server190.RegisteredMutation<"public", {
+  domainId: convex_values2293.GenericId<"GroupConnectionDomain">;
 }, Promise<null>>;
 //#endregion
 export { verification_d_exports };

package/dist/component/connection/domain.d.ts

@@ -1,5 +1,5 @@
-import * as convex_values2785 from "convex/values";
-import * as convex_server189 from "convex/server";
+import * as convex_values2281 from "convex/values";
+import * as convex_server186 from "convex/server";
 
 //#region src/component/connection/domain.d.ts
 declare namespace domain_d_exports {
@@ -15,17 +15,17 @@ declare namespace domain_d_exports {
  * @module
  */
 /** List the domains attached to a connection (`limit` clamped to 1..500, default 100). */
-declare const list: convex_server189.RegisteredQuery<"public", {
+declare const list: convex_server186.RegisteredQuery<"public", {
   limit?: number | undefined;
-  connectionId: convex_values2785.GenericId<"GroupConnection">;
+  connectionId: convex_values2281.GenericId<"GroupConnection">;
 }, Promise<{
-  _id: convex_values2785.GenericId<"GroupConnectionDomain">;
+  _id: convex_values2281.GenericId<"GroupConnectionDomain">;
   _creationTime: number;
   verifiedAt?: number | undefined;
-  isPrimary: boolean;
-  connectionId: convex_values2785.GenericId<"GroupConnection">;
-  groupId: convex_values2785.GenericId<"Group">;
+  connectionId: convex_values2281.GenericId<"GroupConnection">;
   domain: string;
+  groupId: convex_values2281.GenericId<"Group">;
+  isPrimary: boolean;
 }[]>>;
 /**
  * Attach a domain to a connection. Idempotent on `(connectionId, domain)`:
@@ -33,31 +33,31 @@ declare const list: convex_server189.RegisteredQuery<"public", {
  * domain already belongs to a different connection. Setting `isPrimary` demotes
  * any current primary; the first domain on a connection becomes primary by default.
  */
-declare const create: convex_server189.RegisteredMutation<"public", {
+declare const create: convex_server186.RegisteredMutation<"public", {
   isPrimary?: boolean | undefined;
-  connectionId: convex_values2785.GenericId<"GroupConnection">;
-  groupId: convex_values2785.GenericId<"Group">;
+  connectionId: convex_values2281.GenericId<"GroupConnection">;
   domain: string;
-}, Promise<convex_values2785.GenericId<"GroupConnectionDomain">>>;
+  groupId: convex_values2281.GenericId<"Group">;
+}, Promise<convex_values2281.GenericId<"GroupConnectionDomain">>>;
 /** Delete a domain and its dependent verification record, if any. */
-declare const remove: convex_server189.RegisteredMutation<"public", {
-  id: convex_values2785.GenericId<"GroupConnectionDomain">;
+declare const remove: convex_server186.RegisteredMutation<"public", {
+  id: convex_values2281.GenericId<"GroupConnectionDomain">;
 }, Promise<null>>;
 /**
  * Mark a domain verified at `verifiedAt` and clear its pending verification
  * record. Returns the updated domain doc.
  */
-declare const verify: convex_server189.RegisteredMutation<"public", {
-  id: convex_values2785.GenericId<"GroupConnectionDomain">;
+declare const verify: convex_server186.RegisteredMutation<"public", {
+  id: convex_values2281.GenericId<"GroupConnectionDomain">;
   verifiedAt: number;
 }, Promise<{
-  _id: convex_values2785.GenericId<"GroupConnectionDomain">;
+  _id: convex_values2281.GenericId<"GroupConnectionDomain">;
   _creationTime: number;
   verifiedAt?: number | undefined;
-  isPrimary: boolean;
-  connectionId: convex_values2785.GenericId<"GroupConnection">;
-  groupId: convex_values2785.GenericId<"Group">;
+  connectionId: convex_values2281.GenericId<"GroupConnection">;
   domain: string;
+  groupId: convex_values2281.GenericId<"Group">;
+  isPrimary: boolean;
 }>>;
 //#endregion
 export { domain_d_exports };

package/dist/component/connection/saml/assertion.d.ts

@@ -1,5 +1,5 @@
-import * as convex_values2784 from "convex/values";
-import * as convex_server188 from "convex/server";
+import * as convex_values2280 from "convex/values";
+import * as convex_server185 from "convex/server";
 
 //#region src/component/connection/saml/assertion.d.ts
 declare namespace assertion_d_exports {
@@ -21,8 +21,8 @@ declare namespace assertion_d_exports {
  * first sighting (the row is inserted); returns `false` if the assertion ID was
  * already recorded, signalling a replay the caller must reject.
  */
-declare const accept: convex_server188.RegisteredMutation<"public", {
-  connectionId: convex_values2784.GenericId<"GroupConnection">;
+declare const accept: convex_server185.RegisteredMutation<"public", {
+  connectionId: convex_values2280.GenericId<"GroupConnection">;
   expiresAt: number;
   assertionId: string;
 }, Promise<boolean>>;

package/dist/component/connection/saml/request.d.ts

@@ -1,5 +1,5 @@
-import * as convex_values2781 from "convex/values";
-import * as convex_server186 from "convex/server";
+import * as convex_values2277 from "convex/values";
+import * as convex_server183 from "convex/server";
 
 //#region src/component/connection/saml/request.d.ts
 declare namespace request_d_exports {
@@ -17,12 +17,12 @@ declare namespace request_d_exports {
  * @module
  */
 /** Persist a pending SAML AuthnRequest ID so the ACS handler can accept it once. */
-declare const create: convex_server186.RegisteredMutation<"public", {
-  connectionId: convex_values2781.GenericId<"GroupConnection">;
-  createdAt: number;
-  expiresAt: number;
+declare const create: convex_server183.RegisteredMutation<"public", {
   requestId: string;
-}, Promise<convex_values2781.GenericId<"SamlLoginRequest">>>;
+  connectionId: convex_values2277.GenericId<"GroupConnection">;
+  expiresAt: number;
+  createdAt: number;
+}, Promise<convex_values2277.GenericId<"SamlLoginRequest">>>;
 /**
  * Atomically accept a pending SAML AuthnRequest by its `requestId`. Returns
  * `true` only when a matching, unaccepted, unexpired row existed and was
@@ -37,8 +37,8 @@ declare const create: convex_server186.RegisteredMutation<"public", {
  * connection can still accept it (a wrong-connection probe cannot burn a
  * legitimate pending request).
  */
-declare const accept: convex_server186.RegisteredMutation<"public", {
-  connectionId?: convex_values2781.GenericId<"GroupConnection"> | undefined;
+declare const accept: convex_server183.RegisteredMutation<"public", {
+  connectionId?: convex_values2277.GenericId<"GroupConnection"> | undefined;
   requestId: string;
   now: number;
 }, Promise<boolean>>;

package/dist/component/connection/saml/request.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"request.d.ts","names":[],"sources":["../../../../src/component/connection/saml/request.ts"],"mappings":";;;;;;;;;;;;;;;;AAiBA;;;cAAa,MAAA,mBAAM,kBAAA;gBAWjB,iBAAA,CAAA,SAAA;;;;;;;;;;;;;;;AAgBF;;;;cAAa,MAAA,mBAAM,kBAAA;iBAqBjB,iBAAA,CAAA,SAAA"}
+{"version":3,"file":"request.d.ts","names":[],"sources":["../../../../src/component/connection/saml/request.ts"],"mappings":";;;;;;;;;;;;;;;;AAiBA;;;cAAa,MAAA,mBAAM,kBAAA;;gBAWjB,iBAAA,CAAA,SAAA;;;;;;;;;;;;;;AAgBF;;;;cAAa,MAAA,mBAAM,kBAAA;iBAqBjB,iBAAA,CAAA,SAAA"}

package/dist/component/connection/scim/config.d.ts

@@ -1,5 +1,5 @@
-import * as convex_values2815 from "convex/values";
-import * as convex_server199 from "convex/server";
+import * as convex_values3234 from "convex/values";
+import * as convex_server201 from "convex/server";
 
 //#region src/component/connection/scim/config.d.ts
 declare namespace config_d_exports {
@@ -18,30 +18,30 @@ declare namespace config_d_exports {
  * Read a SCIM config. Overloaded: lookup by `{ tokenHash }` (bearer-token
  * resolution) or by `{ connectionId }`. Returns `null` when nothing matches.
  */
-declare const get: convex_server199.RegisteredQuery<"public", {
-  connectionId?: convex_values2815.GenericId<"GroupConnection"> | undefined;
+declare const get: convex_server201.RegisteredQuery<"public", {
+  connectionId?: convex_values3234.GenericId<"GroupConnection"> | undefined;
   tokenHash?: string | undefined;
 }, Promise<{
-  _id: convex_values2815.GenericId<"GroupConnectionScimConfig">;
+  _id: convex_values3234.GenericId<"GroupConnectionScimConfig">;
   _creationTime: number;
   extend?: any;
   lastRotatedAt?: number | undefined;
-  connectionId: convex_values2815.GenericId<"GroupConnection">;
-  status: "draft" | "active" | "disabled";
-  groupId: convex_values2815.GenericId<"Group">;
+  connectionId: convex_values3234.GenericId<"GroupConnection">;
+  groupId: convex_values3234.GenericId<"Group">;
+  status: "active" | "draft" | "disabled";
   tokenHash: string;
   basePath: string;
 } | null>>;
 /** Insert a SCIM config, or patch it when one already exists for the connection (keyed by `connectionId`). */
-declare const upsert: convex_server199.RegisteredMutation<"public", {
+declare const upsert: convex_server201.RegisteredMutation<"public", {
   extend?: any;
   lastRotatedAt?: number | undefined;
-  connectionId: convex_values2815.GenericId<"GroupConnection">;
-  status: "draft" | "active" | "disabled";
-  groupId: convex_values2815.GenericId<"Group">;
+  connectionId: convex_values3234.GenericId<"GroupConnection">;
+  groupId: convex_values3234.GenericId<"Group">;
+  status: "active" | "draft" | "disabled";
   tokenHash: string;
   basePath: string;
-}, Promise<convex_values2815.GenericId<"GroupConnectionScimConfig">>>;
+}, Promise<convex_values3234.GenericId<"GroupConnectionScimConfig">>>;
 //#endregion
 export { config_d_exports };
 //# sourceMappingURL=config.d.ts.map

package/dist/component/connection/scim/identity.d.ts

@@ -1,9 +1,9 @@
-import * as convex_values2822 from "convex/values";
-import * as convex_server201 from "convex/server";
+import * as convex_values3241 from "convex/values";
+import * as convex_server203 from "convex/server";
 
 //#region src/component/connection/scim/identity.d.ts
 declare namespace identity_d_exports {
-  export { get, list, provision, remove, upsert };
+  export { get, list, provision, provisionGroup, revoke, revokeGroup, update, updateGroup };
 }
 /**
  * `component.connection.scim.identity.*` — SCIM-provisioned
@@ -21,41 +21,41 @@ declare namespace identity_d_exports {
  * identity by `(connectionId, resourceType, externalId)`, `(connectionId,
  * userId)`, `userId`, or `mappedGroupId`. Returns `null` when nothing matches.
  */
-declare const get: convex_server201.RegisteredQuery<"public", {
-  userId?: convex_values2822.GenericId<"User"> | undefined;
-  connectionId?: convex_values2822.GenericId<"GroupConnection"> | undefined;
-  externalId?: string | undefined;
+declare const get: convex_server203.RegisteredQuery<"public", {
+  userId?: convex_values3241.GenericId<"User"> | undefined;
+  connectionId?: convex_values3241.GenericId<"GroupConnection"> | undefined;
   resourceType?: "user" | "group" | undefined;
-  mappedGroupId?: convex_values2822.GenericId<"Group"> | undefined;
-  userIds?: convex_values2822.GenericId<"User">[] | undefined;
+  externalId?: string | undefined;
+  mappedGroupId?: convex_values3241.GenericId<"Group"> | undefined;
+  userIds?: convex_values3241.GenericId<"User">[] | undefined;
 }, Promise<{
-  _id: convex_values2822.GenericId<"GroupConnectionScimIdentity">;
+  _id: convex_values3241.GenericId<"GroupConnectionScimIdentity">;
   _creationTime: number;
-  userId?: convex_values2822.GenericId<"User"> | undefined;
+  userId?: convex_values3241.GenericId<"User"> | undefined;
+  externalId?: string | undefined;
   active?: boolean | undefined;
-  mappedGroupId?: convex_values2822.GenericId<"Group"> | undefined;
+  mappedGroupId?: convex_values3241.GenericId<"Group"> | undefined;
   lastProvisionedAt?: number | undefined;
   raw?: any;
-  connectionId: convex_values2822.GenericId<"GroupConnection">;
-  externalId: string;
-  groupId: convex_values2822.GenericId<"Group">;
+  connectionId: convex_values3241.GenericId<"GroupConnection">;
   resourceType: "user" | "group";
+  groupId: convex_values3241.GenericId<"Group">;
 } | ({
-  _id: convex_values2822.GenericId<"GroupConnectionScimIdentity">;
+  _id: convex_values3241.GenericId<"GroupConnectionScimIdentity">;
   _creationTime: number;
-  userId?: convex_values2822.GenericId<"User"> | undefined;
+  userId?: convex_values3241.GenericId<"User"> | undefined;
+  externalId?: string | undefined;
   active?: boolean | undefined;
-  mappedGroupId?: convex_values2822.GenericId<"Group"> | undefined;
+  mappedGroupId?: convex_values3241.GenericId<"Group"> | undefined;
   lastProvisionedAt?: number | undefined;
   raw?: any;
-  connectionId: convex_values2822.GenericId<"GroupConnection">;
-  externalId: string;
-  groupId: convex_values2822.GenericId<"Group">;
+  connectionId: convex_values3241.GenericId<"GroupConnection">;
   resourceType: "user" | "group";
+  groupId: convex_values3241.GenericId<"Group">;
 } | null)[] | null>>;
 /** List a connection's SCIM identities, paginated. */
-declare const list: convex_server201.RegisteredQuery<"public", {
-  connectionId: convex_values2822.GenericId<"GroupConnection">;
+declare const list: convex_server203.RegisteredQuery<"public", {
+  connectionId: convex_values3241.GenericId<"GroupConnection">;
   paginationOpts: {
     id?: number;
     endCursor?: string | null;
@@ -64,66 +64,109 @@ declare const list: convex_server201.RegisteredQuery<"public", {
     numItems: number;
     cursor: string | null;
   };
-}, Promise<convex_server201.PaginationResult<{
-  _id: convex_values2822.GenericId<"GroupConnectionScimIdentity">;
+}, Promise<convex_server203.PaginationResult<{
+  _id: convex_values3241.GenericId<"GroupConnectionScimIdentity">;
   _creationTime: number;
-  userId?: convex_values2822.GenericId<"User"> | undefined;
+  userId?: convex_values3241.GenericId<"User"> | undefined;
+  externalId?: string | undefined;
   active?: boolean | undefined;
-  mappedGroupId?: convex_values2822.GenericId<"Group"> | undefined;
+  mappedGroupId?: convex_values3241.GenericId<"Group"> | undefined;
   lastProvisionedAt?: number | undefined;
   raw?: any;
-  connectionId: convex_values2822.GenericId<"GroupConnection">;
-  externalId: string;
-  groupId: convex_values2822.GenericId<"Group">;
+  connectionId: convex_values3241.GenericId<"GroupConnection">;
   resourceType: "user" | "group";
+  groupId: convex_values3241.GenericId<"Group">;
 }>>>;
-/** Insert a SCIM identity, or patch it when it already exists (keyed by `(connectionId, resourceType, externalId)`). */
-declare const upsert: convex_server201.RegisteredMutation<"public", {
-  userId?: convex_values2822.GenericId<"User"> | undefined;
-  active?: boolean | undefined;
-  mappedGroupId?: convex_values2822.GenericId<"Group"> | undefined;
-  lastProvisionedAt?: number | undefined;
-  raw?: any;
-  connectionId: convex_values2822.GenericId<"GroupConnection">;
-  externalId: string;
-  groupId: convex_values2822.GenericId<"Group">;
-  resourceType: "user" | "group";
-}, Promise<convex_values2822.GenericId<"GroupConnectionScimIdentity">>>;
 /**
- * Atomically provision or resolve a SCIM user by both of its durable natural
- * keys: the connection-scoped SCIM external id and the provider Account id.
- * A concurrent retry cannot commit a losing User because the identity and
- * Account index reads participate in the same OCC transaction as the inserts.
- * Existing ownership is preserved; conflicting owners are rejected.
+ * Atomically provision a directory-managed user, account, SCIM identity, and
+ * membership. Group and provider ownership are derived from the connection.
  */
-declare const provision: convex_server201.RegisteredMutation<"public", {
+declare const provision: convex_server203.RegisteredMutation<"public", {
+  externalId?: string | undefined;
   active?: boolean | undefined;
   lastProvisionedAt?: number | undefined;
   raw?: any;
-  provider: string;
-  connectionId: convex_values2822.GenericId<"GroupConnection">;
-  externalId: string;
-  groupId: convex_values2822.GenericId<"Group">;
+  connectionId: convex_values3241.GenericId<"GroupConnection">;
+  roleIds: string[];
   userData: {
-    name?: string | undefined;
     email?: string | undefined;
-    image?: string | undefined;
+    extend?: any;
     phone?: string | undefined;
+    name?: string | undefined;
     firstName?: string | undefined;
     lastName?: string | undefined;
+    image?: string | undefined;
     emailVerificationTime?: number | undefined;
     phoneVerificationTime?: number | undefined;
     isAnonymous?: boolean | undefined;
-    lastActiveGroup?: convex_values2822.GenericId<"Group"> | undefined;
+    lastActiveGroup?: convex_values3241.GenericId<"Group"> | undefined;
+    sessionEpoch?: number | undefined;
+  };
+  profileUpdate: "never" | "missing" | "always";
+}, Promise<{
+  userId: convex_values3241.GenericId<"User">;
+  created: boolean;
+}>>;
+/** Atomically update a directory-managed user and its connection membership. */
+declare const update: convex_server203.RegisteredMutation<"public", {
+  externalId?: string | undefined;
+  lastProvisionedAt?: number | undefined;
+  raw?: any;
+  userId: convex_values3241.GenericId<"User">;
+  connectionId: convex_values3241.GenericId<"GroupConnection">;
+  active: boolean;
+  roleIds: string[];
+  userData: {
+    email?: string | undefined;
     extend?: any;
+    phone?: string | undefined;
+    name?: string | undefined;
+    firstName?: string | undefined;
+    lastName?: string | undefined;
+    image?: string | undefined;
+    emailVerificationTime?: number | undefined;
+    phoneVerificationTime?: number | undefined;
+    isAnonymous?: boolean | undefined;
+    lastActiveGroup?: convex_values3241.GenericId<"Group"> | undefined;
+    sessionEpoch?: number | undefined;
   };
+  profileUpdate: "never" | "missing" | "always";
+}, Promise<null>>;
+/** Atomically revoke a directory-managed user's membership, sessions, and identity. */
+declare const revoke: convex_server203.RegisteredMutation<"public", {
+  userId: convex_values3241.GenericId<"User">;
+  connectionId: convex_values3241.GenericId<"GroupConnection">;
+  mode: "soft" | "hard";
 }, Promise<{
-  userId: convex_values2822.GenericId<"User">;
+  epoch: number;
+  cleanedSessions: number;
+  cleanupPending: boolean;
+}>>;
+/** Atomically provision a SCIM group, its identity, and its complete membership. */
+declare const provisionGroup: convex_server203.RegisteredMutation<"public", {
+  externalId?: string | undefined;
+  raw?: any;
+  name: string;
+  connectionId: convex_values3241.GenericId<"GroupConnection">;
+  roleIds: string[];
+  memberIds: convex_values3241.GenericId<"User">[];
+}, Promise<{
+  groupId: convex_values3241.GenericId<"Group">;
   created: boolean;
 }>>;
-/** Delete a SCIM identity by id. */
-declare const remove: convex_server201.RegisteredMutation<"public", {
-  id: convex_values2822.GenericId<"GroupConnectionScimIdentity">;
+/** Atomically update a SCIM group and replace its complete membership. */
+declare const updateGroup: convex_server203.RegisteredMutation<"public", {
+  name?: string | undefined;
+  raw?: any;
+  connectionId: convex_values3241.GenericId<"GroupConnection">;
+  groupId: convex_values3241.GenericId<"Group">;
+  roleIds: string[];
+  memberIds: convex_values3241.GenericId<"User">[];
+}, Promise<null>>;
+/** Atomically revoke a SCIM group and its identity after verifying connection ownership. */
+declare const revokeGroup: convex_server203.RegisteredMutation<"public", {
+  connectionId: convex_values3241.GenericId<"GroupConnection">;
+  groupId: convex_values3241.GenericId<"Group">;
 }, Promise<null>>;
 //#endregion
 export { identity_d_exports };

package/dist/component/connection/scim/identity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"identity.d.ts","names":[],"sources":["../../../../src/component/connection/scim/identity.ts"],"mappings":";;;;;;;;;;;;;;;;;;;AAoCA;;;;cAAa,GAAA,mBAAG,eAAA;WAqEd,iBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGW,IAAA,mBAAI,eAAA;gBAYf,iBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;cAGW,MAAA,mBAAM,kBAAA;WA6BjB,iBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;cASW,SAAA,mBAAS,kBAAA;;;;;gBAmFpB,iBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;cAGI,MAAA,mBAAM,kBAAA;MAOV,iBAAA,CAAA,SAAA;AAAA"}
+{"version":3,"file":"identity.d.ts","names":[],"sources":["../../../../src/component/connection/scim/identity.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA2CA;cAAa,GAAA,mBAAG,eAAA;WAqEd,iBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGW,IAAA,mBAAI,eAAA;gBAYf,iBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;cA6BW,SAAA,mBAAS,kBAAA;;;;;gBAmHpB,iBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;cAGW,MAAA,mBAAM,kBAAA;;;;UA0IjB,iBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;cAGW,MAAA,mBAAM,kBAAA;UAsEjB,iBAAA,CAAA,SAAA;;;;;;;;;cA+EW,cAAA,mBAAc,kBAAA;;;;gBA0EzB,iBAAA,CAAA,SAAA;;;;;;;;cAGW,WAAA,mBAAW,kBAAA;;;gBA4CtB,iBAAA,CAAA,SAAA;;;;;;cAGW,WAAA,mBAAW,kBAAA;gBAoCtB,iBAAA,CAAA,SAAA"}