@estifanos-sh/convex-auth 0.0.11 → 0.0.12

package/dist/component/account.d.ts

@@ -1,6 +1,6 @@
 import { SessionRows } from "./session.js";
-import * as convex_values1749 from "convex/values";
-import * as convex_server150 from "convex/server";
+import * as convex_values1530 from "convex/values";
+import * as convex_server81 from "convex/server";
 
 //#region src/component/account.d.ts
 declare namespace account_d_exports {
@@ -10,7 +10,7 @@ type AcceptedCredentialsSignIn = Omit<SessionRows, "epoch"> & {
   status: "accepted";
 };
 /** Reserve a password attempt and load all sign-in state in one transaction. */
-declare const beginCredentialsSignIn: convex_server150.RegisteredMutation<"public", {
+declare const beginCredentialsSignIn: convex_server81.RegisteredMutation<"public", {
   provider: string;
   providerAccountId: string;
   limitIdentifier: string;
@@ -30,18 +30,18 @@ declare const beginCredentialsSignIn: convex_server150.RegisteredMutation<"publi
 } | {
   status: "ready";
   account: {
-    _id: convex_values1749.GenericId<"Account">;
+    _id: convex_values1530.GenericId<"Account">;
     _creationTime: number;
     extend?: any;
     secret?: string | undefined;
     emailVerified?: string | undefined;
     phoneVerified?: string | undefined;
-    userId: convex_values1749.GenericId<"User">;
+    userId: convex_values1530.GenericId<"User">;
     provider: string;
     providerAccountId: string;
   };
   user: {
-    _id: convex_values1749.GenericId<"User">;
+    _id: convex_values1530.GenericId<"User">;
     _creationTime: number;
     email?: string | undefined;
     phone?: string | undefined;
@@ -53,20 +53,20 @@ declare const beginCredentialsSignIn: convex_server150.RegisteredMutation<"publi
     emailVerificationTime?: number | undefined;
     phoneVerificationTime?: number | undefined;
     isAnonymous?: boolean | undefined;
-    lastActiveGroup?: convex_values1749.GenericId<"Group"> | undefined;
+    lastActiveGroup?: convex_values1530.GenericId<"Group"> | undefined;
     sessionEpoch: number;
   };
   hasTotp: boolean;
 }>>;
 /** Refund a verified password attempt and optionally issue its session atomically. */
-declare const completeCredentialsSignIn: convex_server150.RegisteredMutation<"public", {
+declare const completeCredentialsSignIn: convex_server81.RegisteredMutation<"public", {
   replaceSession?: {
-    sessionId: convex_values1749.GenericId<"Session">;
-    authenticatedUserId: convex_values1749.GenericId<"User">;
+    sessionId: convex_values1530.GenericId<"Session">;
+    authenticatedUserId: convex_values1530.GenericId<"User">;
   } | undefined;
   sessionExpirationTime: number;
   refreshTokenExpirationTime: number;
-  accountId: convex_values1749.GenericId<"Account">;
+  accountId: convex_values1530.GenericId<"Account">;
   limitIdentifier: string;
   issueSession: boolean;
   generateTokens: boolean;
@@ -79,18 +79,18 @@ declare const completeCredentialsSignIn: convex_server150.RegisteredMutation<"pu
  * Read an account by id, or by `{ provider, providerAccountId }` when both
  * are given. Returns `null` when no selector matches.
  */
-declare const get: convex_server150.RegisteredQuery<"public", {
-  id?: convex_values1749.GenericId<"Account"> | undefined;
+declare const get: convex_server81.RegisteredQuery<"public", {
+  id?: convex_values1530.GenericId<"Account"> | undefined;
   provider?: string | undefined;
   providerAccountId?: string | undefined;
 }, Promise<{
-  _id: convex_values1749.GenericId<"Account">;
+  _id: convex_values1530.GenericId<"Account">;
   _creationTime: number;
   extend?: any;
   secret?: string | undefined;
   emailVerified?: string | undefined;
   phoneVerified?: string | undefined;
-  userId: convex_values1749.GenericId<"User">;
+  userId: convex_values1530.GenericId<"User">;
   provider: string;
   providerAccountId: string;
 } | null>>;
@@ -101,34 +101,34 @@ declare const get: convex_server150.RegisteredQuery<"public", {
  * public server facade projects these raw records into safe capability
  * summaries before exposing them to application code.
  */
-declare const list: convex_server150.RegisteredQuery<"public", {
-  userId?: convex_values1749.GenericId<"User"> | undefined;
+declare const list: convex_server81.RegisteredQuery<"public", {
+  userId?: convex_values1530.GenericId<"User"> | undefined;
   provider?: string | undefined;
-  userIds?: convex_values1749.GenericId<"User">[] | undefined;
+  userIds?: convex_values1530.GenericId<"User">[] | undefined;
 }, Promise<{
-  _id: convex_values1749.GenericId<"Account">;
+  _id: convex_values1530.GenericId<"Account">;
   _creationTime: number;
   extend?: any;
   secret?: string | undefined;
   emailVerified?: string | undefined;
   phoneVerified?: string | undefined;
-  userId: convex_values1749.GenericId<"User">;
+  userId: convex_values1530.GenericId<"User">;
   provider: string;
   providerAccountId: string;
 }[]>>;
 /** Insert a new account. */
-declare const create: convex_server150.RegisteredMutation<"public", {
+declare const create: convex_server81.RegisteredMutation<"public", {
   extend?: any;
   secret?: string | undefined;
-  userId: convex_values1749.GenericId<"User">;
+  userId: convex_values1530.GenericId<"User">;
   provider: string;
   providerAccountId: string;
-}, Promise<convex_values1749.GenericId<"Account">>>;
+}, Promise<convex_values1530.GenericId<"Account">>>;
 /** Patch fields on an account. */
-declare const update: convex_server150.RegisteredMutation<"public", {
-  id: convex_values1749.GenericId<"Account">;
+declare const update: convex_server81.RegisteredMutation<"public", {
+  id: convex_values1530.GenericId<"Account">;
   patch: {
-    userId?: convex_values1749.GenericId<"User"> | undefined;
+    userId?: convex_values1530.GenericId<"User"> | undefined;
     extend?: any;
     provider?: string | undefined;
     providerAccountId?: string | undefined;
@@ -141,10 +141,10 @@ declare const update: convex_server150.RegisteredMutation<"public", {
  * Delete an account. When `requireOtherAccount` is set, refuses to delete the
  * user's last remaining account so they are never left with none.
  */
-declare const remove: convex_server150.RegisteredMutation<"public", {
-  userId?: convex_values1749.GenericId<"User"> | undefined;
+declare const remove: convex_server81.RegisteredMutation<"public", {
+  userId?: convex_values1530.GenericId<"User"> | undefined;
   requireOtherAccount?: boolean | undefined;
-  id: convex_values1749.GenericId<"Account">;
+  id: convex_values1530.GenericId<"Account">;
 }, Promise<null>>;
 //#endregion
 export { account_d_exports };

package/dist/component/account.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"account.d.ts","names":[],"sources":["../../src/component/account.ts"],"mappings":";;;;;;;;KAwBK,yBAAA,GAA4B,IAAA,CAAK,WAAA;EAA0B,MAAA;AAAA;;cAGnD,sBAAA,mBAAsB,kBAAA;;;;;;;;;;;;;;;;;;;;SAuDjC,iBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGW,yBAAA,mBAAyB,kBAAA;;eA+CpC,iBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;cAMW,GAAA,mBAAG,eAAA;OAmBd,iBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;cASW,IAAA,mBAAI,eAAA;WAgCf,iBAAA,CAAA,SAAA;;;;;;;;;;;;;;;cAGW,MAAA,mBAAM,kBAAA;;;UAqCjB,iBAAA,CAAA,SAAA;;;;;cAGW,MAAA,mBAAM,kBAAA;MAkBjB,iBAAA,CAAA,SAAA;;;;;;;;;;;;;;AA7FF;cAmGM,MAAA,mBAAM,kBAAA;WA6BV,iBAAA,CAAA,SAAA"}
+{"version":3,"file":"account.d.ts","names":[],"sources":["../../src/component/account.ts"],"mappings":";;;;;;;;KAwBK,yBAAA,GAA4B,IAAA,CAAK,WAAA;EAA0B,MAAA;AAAA;;cAGnD,sBAAA,kBAAsB,kBAAA;;;;;;;;;;;;;;;;;;;;SAuDjC,iBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGW,yBAAA,kBAAyB,kBAAA;;eA+CpC,iBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;cAMW,GAAA,kBAAG,eAAA;OAmBd,iBAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;cASW,IAAA,kBAAI,eAAA;WAgCf,iBAAA,CAAA,SAAA;;;;;;;;;;;;;;;cAGW,MAAA,kBAAM,kBAAA;;;UAqCjB,iBAAA,CAAA,SAAA;;;;;cAGW,MAAA,kBAAM,kBAAA;MAkBjB,iBAAA,CAAA,SAAA;;;;;;;;;;;;;;AA7FF;cAmGM,MAAA,kBAAM,kBAAA;WA6BV,iBAAA,CAAA,SAAA"}

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

@@ -1,5 +1,5 @@
-import * as convex_values2763 from "convex/values";
-import * as convex_server229 from "convex/server";
+import * as convex_values1594 from "convex/values";
+import * as convex_server99 from "convex/server";
 
 //#region src/component/connection/audit.d.ts
 declare namespace audit_d_exports {
@@ -15,7 +15,7 @@ declare namespace audit_d_exports {
  * paginated. Requires exactly one of `connectionId` or `groupId`, so a caller
  * cannot scan the whole event log by omitting the scope.
  */
-declare const list: convex_server229.RegisteredQuery<"public", {
+declare const list: convex_server99.RegisteredQuery<"public", {
   paginationOpts: {
     id?: number;
     endCursor?: string | null;
@@ -25,12 +25,12 @@ declare const list: convex_server229.RegisteredQuery<"public", {
     cursor: string | null;
   };
   scope: {
-    connectionId: convex_values2763.GenericId<"GroupConnection">;
+    connectionId: convex_values1594.GenericId<"GroupConnection">;
   } | {
-    groupId: convex_values2763.GenericId<"Group">;
+    groupId: convex_values1594.GenericId<"Group">;
   };
-}, Promise<convex_server229.PaginationResult<{
-  _id: convex_values2763.GenericId<"AuthEventProjection">;
+}, Promise<convex_server99.PaginationResult<{
+  _id: convex_values1594.GenericId<"AuthEventProjection">;
   _creationTime: number;
   requestId?: string | undefined;
   ip?: string | undefined;

package/dist/component/connection/audit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"audit.d.ts","names":[],"sources":["../../../src/component/connection/audit.ts"],"mappings":";;;;;;;;;;;;;AAoBA;;;;cAAa,IAAA,mBAAI,eAAA;;;;;;;;;;kBA6Bf,iBAAA,CAAA,SAAA;EAAA"}
+{"version":3,"file":"audit.d.ts","names":[],"sources":["../../../src/component/connection/audit.ts"],"mappings":";;;;;;;;;;;;;AAoBA;;;;cAAa,IAAA,kBAAI,eAAA;;;;;;;;;;kBA6Bf,iBAAA,CAAA,SAAA;EAAA"}

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

@@ -1,4 +1,4 @@
-import * as convex_server231 from "convex/server";
+import * as convex_server110 from "convex/server";
 
 //#region src/component/connection/cache.d.ts
 declare namespace cache_d_exports {
@@ -27,7 +27,7 @@ declare namespace cache_d_exports {
 /**
  * Read-through fetch for OIDC discovery JSON. Cached 1h per URL.
  */
-declare const oidcDiscovery: convex_server231.RegisteredAction<"public", {
+declare const oidcDiscovery: convex_server110.RegisteredAction<"public", {
   runtimeOrigin?: string | undefined;
   externalHost?: string | undefined;
   url: string;
@@ -45,7 +45,7 @@ declare const oidcDiscovery: convex_server231.RegisteredAction<"public", {
  * Cached 2h per URL (separate from the runtime sign-in path so admin
  * dashboards don't share keys with hot-path traffic).
  */
-declare const oidcStatusDiscovery: convex_server231.RegisteredAction<"public", {
+declare const oidcStatusDiscovery: convex_server110.RegisteredAction<"public", {
   runtimeOrigin?: string | undefined;
   externalHost?: string | undefined;
   url: string;
@@ -61,19 +61,19 @@ declare const oidcStatusDiscovery: convex_server231.RegisteredAction<"public", {
 /**
  * Read-through fetch for SAML IdP metadata XML. Cached 24h per URL.
  */
-declare const samlMetadata: convex_server231.RegisteredAction<"public", {
+declare const samlMetadata: convex_server110.RegisteredAction<"public", {
   runtimeOrigin?: string | undefined;
   externalHost?: string | undefined;
   url: string;
 }, Promise<string>>;
 /** Invalidate a cached OIDC discovery entry (e.g. on `discoveryUrl` update). */
-declare const invalidateOidcDiscovery: convex_server231.RegisteredMutation<"public", {
+declare const invalidateOidcDiscovery: convex_server110.RegisteredMutation<"public", {
   runtimeOrigin?: string | undefined;
   externalHost?: string | undefined;
   url: string;
 }, Promise<null>>;
 /** Invalidate a cached SAML metadata entry (e.g. on `metadataUrl` update). */
-declare const invalidateSamlMetadata: convex_server231.RegisteredMutation<"public", {
+declare const invalidateSamlMetadata: convex_server110.RegisteredMutation<"public", {
   runtimeOrigin?: string | undefined;
   externalHost?: string | undefined;
   url: string;

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

@@ -1,5 +1,5 @@
-import * as convex_values1806 from "convex/values";
-import * as convex_server169 from "convex/server";
+import * as convex_values3744 from "convex/values";
+import * as convex_server254 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_server169.RegisteredQuery<"public", {
-  domainId: convex_values1806.GenericId<"GroupConnectionDomain">;
+declare const get: convex_server254.RegisteredQuery<"public", {
+  domainId: convex_values3744.GenericId<"GroupConnectionDomain">;
 }, Promise<{
-  _id: convex_values1806.GenericId<"GroupConnectionDomainVerification">;
+  _id: convex_values3744.GenericId<"GroupConnectionDomainVerification">;
   _creationTime: number;
-  connectionId: convex_values1806.GenericId<"GroupConnection">;
+  connectionId: convex_values3744.GenericId<"GroupConnection">;
   domain: string;
   recordName: string;
   expiresAt: number;
-  groupId: convex_values1806.GenericId<"Group">;
+  groupId: convex_values3744.GenericId<"Group">;
   tokenHash: string;
-  domainId: convex_values1806.GenericId<"GroupConnectionDomain">;
+  domainId: convex_values3744.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_server169.RegisteredMutation<"public", {
-  connectionId: convex_values1806.GenericId<"GroupConnection">;
+declare const upsert: convex_server254.RegisteredMutation<"public", {
+  connectionId: convex_values3744.GenericId<"GroupConnection">;
   domain: string;
   recordName: string;
   expiresAt: number;
-  groupId: convex_values1806.GenericId<"Group">;
+  groupId: convex_values3744.GenericId<"Group">;
   tokenHash: string;
-  domainId: convex_values1806.GenericId<"GroupConnectionDomain">;
+  domainId: convex_values3744.GenericId<"GroupConnectionDomain">;
   token: string;
   requestedAt: number;
-}, Promise<convex_values1806.GenericId<"GroupConnectionDomainVerification">>>;
+}, Promise<convex_values3744.GenericId<"GroupConnectionDomainVerification">>>;
 /** Delete a domain's verification record, if any. */
-declare const remove: convex_server169.RegisteredMutation<"public", {
-  domainId: convex_values1806.GenericId<"GroupConnectionDomain">;
+declare const remove: convex_server254.RegisteredMutation<"public", {
+  domainId: convex_values3744.GenericId<"GroupConnectionDomain">;
 }, Promise<null>>;
 //#endregion
 export { verification_d_exports };

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

@@ -1,5 +1,5 @@
-import * as convex_values1794 from "convex/values";
-import * as convex_server165 from "convex/server";
+import * as convex_values3719 from "convex/values";
+import * as convex_server244 from "convex/server";
 
 //#region src/component/connection/domain.d.ts
 declare namespace domain_d_exports {
@@ -15,16 +15,16 @@ declare namespace domain_d_exports {
  * @module
  */
 /** List the domains attached to a connection (`limit` clamped to 1..500, default 100). */
-declare const list: convex_server165.RegisteredQuery<"public", {
+declare const list: convex_server244.RegisteredQuery<"public", {
   limit?: number | undefined;
-  connectionId: convex_values1794.GenericId<"GroupConnection">;
+  connectionId: convex_values3719.GenericId<"GroupConnection">;
 }, Promise<{
-  _id: convex_values1794.GenericId<"GroupConnectionDomain">;
+  _id: convex_values3719.GenericId<"GroupConnectionDomain">;
   _creationTime: number;
   verifiedAt?: number | undefined;
-  connectionId: convex_values1794.GenericId<"GroupConnection">;
+  connectionId: convex_values3719.GenericId<"GroupConnection">;
   domain: string;
-  groupId: convex_values1794.GenericId<"Group">;
+  groupId: convex_values3719.GenericId<"Group">;
   isPrimary: boolean;
 }[]>>;
 /**
@@ -33,30 +33,30 @@ declare const list: convex_server165.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_server165.RegisteredMutation<"public", {
+declare const create: convex_server244.RegisteredMutation<"public", {
   isPrimary?: boolean | undefined;
-  connectionId: convex_values1794.GenericId<"GroupConnection">;
+  connectionId: convex_values3719.GenericId<"GroupConnection">;
   domain: string;
-  groupId: convex_values1794.GenericId<"Group">;
-}, Promise<convex_values1794.GenericId<"GroupConnectionDomain">>>;
+  groupId: convex_values3719.GenericId<"Group">;
+}, Promise<convex_values3719.GenericId<"GroupConnectionDomain">>>;
 /** Delete a domain and its dependent verification record, if any. */
-declare const remove: convex_server165.RegisteredMutation<"public", {
-  id: convex_values1794.GenericId<"GroupConnectionDomain">;
+declare const remove: convex_server244.RegisteredMutation<"public", {
+  id: convex_values3719.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_server165.RegisteredMutation<"public", {
-  id: convex_values1794.GenericId<"GroupConnectionDomain">;
+declare const verify: convex_server244.RegisteredMutation<"public", {
+  id: convex_values3719.GenericId<"GroupConnectionDomain">;
   verifiedAt: number;
 }, Promise<{
-  _id: convex_values1794.GenericId<"GroupConnectionDomain">;
+  _id: convex_values3719.GenericId<"GroupConnectionDomain">;
   _creationTime: number;
   verifiedAt?: number | undefined;
-  connectionId: convex_values1794.GenericId<"GroupConnection">;
+  connectionId: convex_values3719.GenericId<"GroupConnection">;
   domain: string;
-  groupId: convex_values1794.GenericId<"Group">;
+  groupId: convex_values3719.GenericId<"Group">;
   isPrimary: boolean;
 }>>;
 //#endregion

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

@@ -1,5 +1,5 @@
-import * as convex_values1772 from "convex/values";
-import * as convex_server159 from "convex/server";
+import * as convex_values3686 from "convex/values";
+import * as convex_server235 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_server159.RegisteredMutation<"public", {
-  connectionId: convex_values1772.GenericId<"GroupConnection">;
+declare const accept: convex_server235.RegisteredMutation<"public", {
+  connectionId: convex_values3686.GenericId<"GroupConnection">;
   expiresAt: number;
   assertionId: string;
 }, Promise<boolean>>;

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

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

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

@@ -1,5 +1,5 @@
-import * as convex_values2720 from "convex/values";
-import * as convex_server218 from "convex/server";
+import * as convex_values3778 from "convex/values";
+import * as convex_server267 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_server218.RegisteredQuery<"public", {
-  connectionId?: convex_values2720.GenericId<"GroupConnection"> | undefined;
+declare const get: convex_server267.RegisteredQuery<"public", {
+  connectionId?: convex_values3778.GenericId<"GroupConnection"> | undefined;
   tokenHash?: string | undefined;
 }, Promise<{
-  _id: convex_values2720.GenericId<"GroupConnectionScimConfig">;
+  _id: convex_values3778.GenericId<"GroupConnectionScimConfig">;
   _creationTime: number;
   extend?: any;
   lastRotatedAt?: number | undefined;
-  connectionId: convex_values2720.GenericId<"GroupConnection">;
-  groupId: convex_values2720.GenericId<"Group">;
+  connectionId: convex_values3778.GenericId<"GroupConnection">;
+  groupId: convex_values3778.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_server218.RegisteredMutation<"public", {
+declare const upsert: convex_server267.RegisteredMutation<"public", {
   extend?: any;
   lastRotatedAt?: number | undefined;
-  connectionId: convex_values2720.GenericId<"GroupConnection">;
-  groupId: convex_values2720.GenericId<"Group">;
+  connectionId: convex_values3778.GenericId<"GroupConnection">;
+  groupId: convex_values3778.GenericId<"Group">;
   status: "active" | "draft" | "disabled";
   tokenHash: string;
   basePath: string;
-}, Promise<convex_values2720.GenericId<"GroupConnectionScimConfig">>>;
+}, Promise<convex_values3778.GenericId<"GroupConnectionScimConfig">>>;
 //#endregion
 export { config_d_exports };
 //# sourceMappingURL=config.d.ts.map