@estifanos-sh/convex-auth 0.0.6 → 0.0.7

package/dist/component/account.d.ts

@@ -1,6 +1,6 @@
 import { SessionRows } from "./session.js";
-import * as convex_values2703 from "convex/values";
-import * as convex_server146 from "convex/server";
+import * as convex_values1512 from "convex/values";
+import * as convex_server83 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_server146.RegisteredMutation<"public", {
+declare const beginCredentialsSignIn: convex_server83.RegisteredMutation<"public", {
   provider: string;
   providerAccountId: string;
   limitIdentifier: string;
@@ -30,22 +30,22 @@ declare const beginCredentialsSignIn: convex_server146.RegisteredMutation<"publi
 } | {
   status: "ready";
   account: {
-    _id: convex_values2703.GenericId<"Account">;
+    _id: convex_values1512.GenericId<"Account">;
     _creationTime: number;
     extend?: any;
     secret?: string | undefined;
     emailVerified?: string | undefined;
     phoneVerified?: string | undefined;
-    userId: convex_values2703.GenericId<"User">;
+    userId: convex_values1512.GenericId<"User">;
     provider: string;
     providerAccountId: string;
   };
   user: {
-    _id: convex_values2703.GenericId<"User">;
+    _id: convex_values1512.GenericId<"User">;
     _creationTime: number;
+    extend?: any;
     email?: string | undefined;
     phone?: string | undefined;
-    extend?: any;
     name?: string | undefined;
     firstName?: string | undefined;
     lastName?: string | undefined;
@@ -53,20 +53,20 @@ declare const beginCredentialsSignIn: convex_server146.RegisteredMutation<"publi
     emailVerificationTime?: number | undefined;
     phoneVerificationTime?: number | undefined;
     isAnonymous?: boolean | undefined;
-    lastActiveGroup?: convex_values2703.GenericId<"Group"> | undefined;
+    lastActiveGroup?: convex_values1512.GenericId<"Group"> | undefined;
     sessionEpoch: number;
   };
   hasTotp: boolean;
 }>>;
 /** Refund a verified password attempt and optionally issue its session atomically. */
-declare const completeCredentialsSignIn: convex_server146.RegisteredMutation<"public", {
+declare const completeCredentialsSignIn: convex_server83.RegisteredMutation<"public", {
   replaceSession?: {
-    sessionId: convex_values2703.GenericId<"Session">;
-    authenticatedUserId: convex_values2703.GenericId<"User">;
+    sessionId: convex_values1512.GenericId<"Session">;
+    authenticatedUserId: convex_values1512.GenericId<"User">;
   } | undefined;
   sessionExpirationTime: number;
   refreshTokenExpirationTime: number;
-  accountId: convex_values2703.GenericId<"Account">;
+  accountId: convex_values1512.GenericId<"Account">;
   limitIdentifier: string;
   issueSession: boolean;
   generateTokens: boolean;
@@ -79,18 +79,18 @@ declare const completeCredentialsSignIn: convex_server146.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_server146.RegisteredQuery<"public", {
-  id?: convex_values2703.GenericId<"Account"> | undefined;
+declare const get: convex_server83.RegisteredQuery<"public", {
+  id?: convex_values1512.GenericId<"Account"> | undefined;
   provider?: string | undefined;
   providerAccountId?: string | undefined;
 }, Promise<{
-  _id: convex_values2703.GenericId<"Account">;
+  _id: convex_values1512.GenericId<"Account">;
   _creationTime: number;
   extend?: any;
   secret?: string | undefined;
   emailVerified?: string | undefined;
   phoneVerified?: string | undefined;
-  userId: convex_values2703.GenericId<"User">;
+  userId: convex_values1512.GenericId<"User">;
   provider: string;
   providerAccountId: string;
 } | null>>;
@@ -101,35 +101,35 @@ declare const get: convex_server146.RegisteredQuery<"public", {
  * public server facade projects these raw records into safe capability
  * summaries before exposing them to application code.
  */
-declare const list: convex_server146.RegisteredQuery<"public", {
-  userId?: convex_values2703.GenericId<"User"> | undefined;
+declare const list: convex_server83.RegisteredQuery<"public", {
+  userId?: convex_values1512.GenericId<"User"> | undefined;
   provider?: string | undefined;
-  userIds?: convex_values2703.GenericId<"User">[] | undefined;
+  userIds?: convex_values1512.GenericId<"User">[] | undefined;
 }, Promise<{
-  _id: convex_values2703.GenericId<"Account">;
+  _id: convex_values1512.GenericId<"Account">;
   _creationTime: number;
   extend?: any;
   secret?: string | undefined;
   emailVerified?: string | undefined;
   phoneVerified?: string | undefined;
-  userId: convex_values2703.GenericId<"User">;
+  userId: convex_values1512.GenericId<"User">;
   provider: string;
   providerAccountId: string;
 }[]>>;
 /** Insert a new account. */
-declare const create: convex_server146.RegisteredMutation<"public", {
+declare const create: convex_server83.RegisteredMutation<"public", {
   extend?: any;
   secret?: string | undefined;
-  userId: convex_values2703.GenericId<"User">;
+  userId: convex_values1512.GenericId<"User">;
   provider: string;
   providerAccountId: string;
-}, Promise<convex_values2703.GenericId<"Account">>>;
+}, Promise<convex_values1512.GenericId<"Account">>>;
 /** Patch fields on an account. */
-declare const update: convex_server146.RegisteredMutation<"public", {
-  id: convex_values2703.GenericId<"Account">;
+declare const update: convex_server83.RegisteredMutation<"public", {
+  id: convex_values1512.GenericId<"Account">;
   patch: {
-    userId?: convex_values2703.GenericId<"User"> | undefined;
     extend?: any;
+    userId?: convex_values1512.GenericId<"User"> | undefined;
     provider?: string | undefined;
     providerAccountId?: string | undefined;
     secret?: string | undefined;
@@ -141,10 +141,10 @@ declare const update: convex_server146.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_server146.RegisteredMutation<"public", {
-  userId?: convex_values2703.GenericId<"User"> | undefined;
+declare const remove: convex_server83.RegisteredMutation<"public", {
+  userId?: convex_values1512.GenericId<"User"> | undefined;
   requireOtherAccount?: boolean | undefined;
-  id: convex_values2703.GenericId<"Account">;
+  id: convex_values1512.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":";;;;;;;;KAuBK,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;WAmCV,iBAAA,CAAA,SAAA"}
+{"version":3,"file":"account.d.ts","names":[],"sources":["../../src/component/account.ts"],"mappings":";;;;;;;;KAuBK,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;WAmCV,iBAAA,CAAA,SAAA"}

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

@@ -1,5 +1,5 @@
-import * as convex_values2831 from "convex/values";
-import * as convex_server183 from "convex/server";
+import * as convex_values1847 from "convex/values";
+import * as convex_server186 from "convex/server";
 
 //#region src/component/connection/audit.d.ts
 declare namespace audit_d_exports {
@@ -16,7 +16,7 @@ declare namespace audit_d_exports {
  * an allowlist). Requires exactly one of `connectionId` or `groupId` — passing
  * neither throws rather than scanning the entire audit log.
  */
-declare const list: convex_server183.RegisteredQuery<"public", {
+declare const list: convex_server186.RegisteredQuery<"public", {
   paginationOpts: {
     id?: number;
     endCursor?: string | null;
@@ -26,23 +26,23 @@ declare const list: convex_server183.RegisteredQuery<"public", {
     cursor: string | null;
   };
   scope: {
-    connectionId: convex_values2831.GenericId<"GroupConnection">;
+    connectionId: convex_values1847.GenericId<"GroupConnection">;
   } | {
-    groupId: convex_values2831.GenericId<"Group">;
+    groupId: convex_values1847.GenericId<"Group">;
   };
 }, Promise<{
   page: {
-    _id: convex_values2831.GenericId<"AuthEventProjection">;
+    _id: convex_values1847.GenericId<"AuthEventProjection">;
     _creationTime: number;
     eventId: string;
     targetKind: "user" | "group" | "session" | "api_key" | "connection" | "oauth_client" | "global";
     targetId: string;
     kind: "user.created" | "user.updated" | "session.signed_in" | "session.signed_out" | "session.invalidated" | "session.refresh_exchanged" | "session.refresh_reuse_detected" | "account.linked" | "account.unlinked" | "password.changed" | "passkey.added" | "passkey.removed" | "totp.enrolled" | "totp.removed" | "email.verified" | "phone.verified" | "api_key.created" | "api_key.revoked" | "oauth.client.created" | "oauth.client.revoked" | "oauth.code.created" | "oauth.token.created" | "oauth.token.exchanged" | "oauth.refresh.reuse_detected" | "oauth.refresh.revoked" | "connection.created" | "connection.updated" | "connection.removed" | "connection.login.succeeded" | "connection.login.failed" | "connection.domain.verification_requested" | "connection.domain.verified" | "connection.policy.updated" | "connection.saml.set" | "connection.saml.refreshed" | "connection.oidc.set" | "connection.scim.set" | "connection.scim.read" | "connection.scim.user.provisioned" | "connection.scim.user.updated" | "connection.scim.user.deactivated" | "connection.scim.user.reactivated" | "connection.scim.group.provisioned" | "connection.scim.group.updated" | "connection.scim.group.deactivated" | "connection.scim.group.reactivated" | "webhook.endpoint.created" | "webhook.endpoint.disabled" | "webhook.delivery.created" | "webhook.delivery.attempted" | "webhook.delivery.succeeded" | "webhook.delivery.failed";
-    category: "user" | "session" | "account" | "password" | "passkey" | "totp" | "email" | "phone" | "api_key" | "oauth" | "connection" | "scim" | "webhook" | "security";
+    category: "email" | "user" | "session" | "account" | "password" | "passkey" | "totp" | "phone" | "api_key" | "oauth" | "connection" | "scim" | "webhook" | "security";
     occurredAt: number;
     actorType: "user" | "api_key" | "scim" | "webhook" | "system" | "oauth_client" | "anonymous";
     actorId: string | undefined;
-    subjectType: "user" | "group" | "session" | "account" | "passkey" | "totp" | "email" | "phone" | "api_key" | "connection" | "system" | "oauth_client" | "oauth_code" | "scim_identity" | "webhook_endpoint" | "webhook_delivery";
+    subjectType: "email" | "user" | "group" | "session" | "account" | "passkey" | "totp" | "phone" | "api_key" | "connection" | "system" | "oauth_client" | "oauth_code" | "scim_identity" | "webhook_endpoint" | "webhook_delivery";
     subjectId: string | undefined;
     outcome: "success" | "failure";
     errorCode: string | undefined;
@@ -50,8 +50,8 @@ declare const list: convex_server183.RegisteredQuery<"public", {
     ip: undefined;
     data: {
       type?: string | undefined;
-      provider?: string | undefined;
       profile?: Record<string, any> | undefined;
+      provider?: string | undefined;
       existingUserId?: string | undefined;
     } | {
       method?: string | undefined;
@@ -75,8 +75,8 @@ declare const list: convex_server183.RegisteredQuery<"public", {
       name?: string | undefined;
       prefix?: string | undefined;
     } | {
-      userId?: string | undefined;
       email?: string | undefined;
+      userId?: string | undefined;
       phone?: string | undefined;
     } | {
       userId?: string | undefined;
@@ -125,8 +125,8 @@ declare const list: convex_server183.RegisteredQuery<"public", {
     } | undefined;
   }[];
   isDone: boolean;
-  continueCursor: convex_server183.Cursor;
-  splitCursor?: convex_server183.Cursor | null;
+  continueCursor: convex_server186.Cursor;
+  splitCursor?: convex_server186.Cursor | null;
   pageStatus?: "SplitRecommended" | "SplitRequired" | null;
 }>>;
 //#endregion

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

@@ -1,4 +1,4 @@
-import * as convex_server192 from "convex/server";
+import * as convex_server189 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_server192.RegisteredAction<"public", {
+declare const oidcDiscovery: convex_server189.RegisteredAction<"public", {
   runtimeOrigin?: string | undefined;
   externalHost?: string | undefined;
   url: string;
@@ -45,7 +45,7 @@ declare const oidcDiscovery: convex_server192.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_server192.RegisteredAction<"public", {
+declare const oidcStatusDiscovery: convex_server189.RegisteredAction<"public", {
   runtimeOrigin?: string | undefined;
   externalHost?: string | undefined;
   url: string;
@@ -61,19 +61,19 @@ declare const oidcStatusDiscovery: convex_server192.RegisteredAction<"public", {
 /**
  * Read-through fetch for SAML IdP metadata XML. Cached 24h per URL.
  */
-declare const samlMetadata: convex_server192.RegisteredAction<"public", {
+declare const samlMetadata: convex_server189.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_server192.RegisteredMutation<"public", {
+declare const invalidateOidcDiscovery: convex_server189.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_server192.RegisteredMutation<"public", {
+declare const invalidateSamlMetadata: convex_server189.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_values2517 from "convex/values";
-import * as convex_server119 from "convex/server";
+import * as convex_values1774 from "convex/values";
+import * as convex_server165 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_server119.RegisteredQuery<"public", {
-  domainId: convex_values2517.GenericId<"GroupConnectionDomain">;
+declare const get: convex_server165.RegisteredQuery<"public", {
+  domainId: convex_values1774.GenericId<"GroupConnectionDomain">;
 }, Promise<{
-  _id: convex_values2517.GenericId<"GroupConnectionDomainVerification">;
+  _id: convex_values1774.GenericId<"GroupConnectionDomainVerification">;
   _creationTime: number;
-  connectionId: convex_values2517.GenericId<"GroupConnection">;
+  connectionId: convex_values1774.GenericId<"GroupConnection">;
   domain: string;
   recordName: string;
   expiresAt: number;
-  groupId: convex_values2517.GenericId<"Group">;
+  groupId: convex_values1774.GenericId<"Group">;
   tokenHash: string;
-  domainId: convex_values2517.GenericId<"GroupConnectionDomain">;
+  domainId: convex_values1774.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_server119.RegisteredMutation<"public", {
-  connectionId: convex_values2517.GenericId<"GroupConnection">;
+declare const upsert: convex_server165.RegisteredMutation<"public", {
+  connectionId: convex_values1774.GenericId<"GroupConnection">;
   domain: string;
   recordName: string;
   expiresAt: number;
-  groupId: convex_values2517.GenericId<"Group">;
+  groupId: convex_values1774.GenericId<"Group">;
   tokenHash: string;
-  domainId: convex_values2517.GenericId<"GroupConnectionDomain">;
+  domainId: convex_values1774.GenericId<"GroupConnectionDomain">;
   token: string;
   requestedAt: number;
-}, Promise<convex_values2517.GenericId<"GroupConnectionDomainVerification">>>;
+}, Promise<convex_values1774.GenericId<"GroupConnectionDomainVerification">>>;
 /** Delete a domain's verification record, if any. */
-declare const remove: convex_server119.RegisteredMutation<"public", {
-  domainId: convex_values2517.GenericId<"GroupConnectionDomain">;
+declare const remove: convex_server165.RegisteredMutation<"public", {
+  domainId: convex_values1774.GenericId<"GroupConnectionDomain">;
 }, Promise<null>>;
 //#endregion
 export { verification_d_exports };

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

@@ -1,5 +1,5 @@
-import * as convex_values1973 from "convex/values";
-import * as convex_server103 from "convex/server";
+import * as convex_values1784 from "convex/values";
+import * as convex_server168 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_server103.RegisteredQuery<"public", {
+declare const list: convex_server168.RegisteredQuery<"public", {
   limit?: number | undefined;
-  connectionId: convex_values1973.GenericId<"GroupConnection">;
+  connectionId: convex_values1784.GenericId<"GroupConnection">;
 }, Promise<{
-  _id: convex_values1973.GenericId<"GroupConnectionDomain">;
+  _id: convex_values1784.GenericId<"GroupConnectionDomain">;
   _creationTime: number;
   verifiedAt?: number | undefined;
-  connectionId: convex_values1973.GenericId<"GroupConnection">;
+  connectionId: convex_values1784.GenericId<"GroupConnection">;
   domain: string;
-  groupId: convex_values1973.GenericId<"Group">;
+  groupId: convex_values1784.GenericId<"Group">;
   isPrimary: boolean;
 }[]>>;
 /**
@@ -33,30 +33,30 @@ declare const list: convex_server103.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_server103.RegisteredMutation<"public", {
+declare const create: convex_server168.RegisteredMutation<"public", {
   isPrimary?: boolean | undefined;
-  connectionId: convex_values1973.GenericId<"GroupConnection">;
+  connectionId: convex_values1784.GenericId<"GroupConnection">;
   domain: string;
-  groupId: convex_values1973.GenericId<"Group">;
-}, Promise<convex_values1973.GenericId<"GroupConnectionDomain">>>;
+  groupId: convex_values1784.GenericId<"Group">;
+}, Promise<convex_values1784.GenericId<"GroupConnectionDomain">>>;
 /** Delete a domain and its dependent verification record, if any. */
-declare const remove: convex_server103.RegisteredMutation<"public", {
-  id: convex_values1973.GenericId<"GroupConnectionDomain">;
+declare const remove: convex_server168.RegisteredMutation<"public", {
+  id: convex_values1784.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_server103.RegisteredMutation<"public", {
-  id: convex_values1973.GenericId<"GroupConnectionDomain">;
+declare const verify: convex_server168.RegisteredMutation<"public", {
+  id: convex_values1784.GenericId<"GroupConnectionDomain">;
   verifiedAt: number;
 }, Promise<{
-  _id: convex_values1973.GenericId<"GroupConnectionDomain">;
+  _id: convex_values1784.GenericId<"GroupConnectionDomain">;
   _creationTime: number;
   verifiedAt?: number | undefined;
-  connectionId: convex_values1973.GenericId<"GroupConnection">;
+  connectionId: convex_values1784.GenericId<"GroupConnection">;
   domain: string;
-  groupId: convex_values1973.GenericId<"Group">;
+  groupId: convex_values1784.GenericId<"Group">;
   isPrimary: boolean;
 }>>;
 //#endregion

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

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

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

@@ -1,5 +1,5 @@
-import * as convex_values1965 from "convex/values";
-import * as convex_server94 from "convex/server";
+import * as convex_values1770 from "convex/values";
+import * as convex_server162 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_server94.RegisteredMutation<"public", {
+declare const create: convex_server162.RegisteredMutation<"public", {
   requestId: string;
-  connectionId: convex_values1965.GenericId<"GroupConnection">;
+  connectionId: convex_values1770.GenericId<"GroupConnection">;
   expiresAt: number;
-}, Promise<convex_values1965.GenericId<"SamlLoginRequest">>>;
+}, Promise<convex_values1770.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_server94.RegisteredMutation<"public", {
  * connection can still accept it (a wrong-connection probe cannot burn a
  * legitimate pending request).
  */
-declare const accept: convex_server94.RegisteredMutation<"public", {
-  connectionId?: convex_values1965.GenericId<"GroupConnection"> | undefined;
+declare const accept: convex_server162.RegisteredMutation<"public", {
+  connectionId?: convex_values1770.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,kBAAM,kBAAA;;gBAUjB,iBAAA,CAAA,SAAA;;;;;;;;;;;;;AAgBF;;;;cAAa,MAAA,kBAAM,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;;gBAUjB,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_values2785 from "convex/values";
-import * as convex_server170 from "convex/server";
+import * as convex_values1796 from "convex/values";
+import * as convex_server172 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_server170.RegisteredQuery<"public", {
-  connectionId?: convex_values2785.GenericId<"GroupConnection"> | undefined;
+declare const get: convex_server172.RegisteredQuery<"public", {
+  connectionId?: convex_values1796.GenericId<"GroupConnection"> | undefined;
   tokenHash?: string | undefined;
 }, Promise<{
-  _id: convex_values2785.GenericId<"GroupConnectionScimConfig">;
+  _id: convex_values1796.GenericId<"GroupConnectionScimConfig">;
   _creationTime: number;
   extend?: any;
   lastRotatedAt?: number | undefined;
-  connectionId: convex_values2785.GenericId<"GroupConnection">;
-  groupId: convex_values2785.GenericId<"Group">;
+  connectionId: convex_values1796.GenericId<"GroupConnection">;
+  groupId: convex_values1796.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_server170.RegisteredMutation<"public", {
+declare const upsert: convex_server172.RegisteredMutation<"public", {
   extend?: any;
   lastRotatedAt?: number | undefined;
-  connectionId: convex_values2785.GenericId<"GroupConnection">;
-  groupId: convex_values2785.GenericId<"Group">;
+  connectionId: convex_values1796.GenericId<"GroupConnection">;
+  groupId: convex_values1796.GenericId<"Group">;
   status: "active" | "draft" | "disabled";
   tokenHash: string;
   basePath: string;
-}, Promise<convex_values2785.GenericId<"GroupConnectionScimConfig">>>;
+}, Promise<convex_values1796.GenericId<"GroupConnectionScimConfig">>>;
 //#endregion
 export { config_d_exports };
 //# sourceMappingURL=config.d.ts.map