@robelest/convex-auth 0.0.4-preview.18 → 0.0.4-preview.19

package/dist/component/providers/email.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"email.d.ts","names":[],"sources":["../../../src/providers/email.ts"],"mappings":";;AASA;;;;UAAiB,mBAAA;EAIf;EAFA,IAAA;EAIU;EAFV,IAAA,GACE,GAAA,OACA,IAAA;IAAQ,IAAA;IAAc,EAAA;IAAY,OAAA;IAAiB,IAAA;EAAA,MAChD,OAAA;EAE6B;EAAlC,yBAAA,SAAkC,OAAA;EAIlC;EAFA,EAAA;EAEM;EAAN,MAAA;AAAA;AAAA,cAGW,KAAA;EAAA,SAIiB,MAAA,EAAQ,mBAAA;EAAA,SAH3B,EAAA;EAAA,SACA,IAAA;cAEmB,MAAA,EAAQ,mBAAA;AAAA"}
+{"version":3,"file":"email.d.ts","names":[],"sources":["../../../src/providers/email.ts"],"mappings":";;AAeA;;;;;;;;;;UAAiB,mBAAA;EAMb;EAJF,IAAA;EAOA;EALA,IAAA,GACE,GAAA,OACA,IAAA;IAAQ,IAAA;IAAc,EAAA;IAAY,OAAA;IAAiB,IAAA;EAAA,MAChD,OAAA;EA2BW;EAzBhB,yBAAA,SAAkC,OAAA;EAmCqB;EAjCvD,EAAA;EAiCoC;EA/BpC,MAAA;AAAA;;;;;;;;;;;;;;;;;;;cAqBW,KAAA;EAAA,SAUiB,MAAA,EAAQ,mBAAA;EAAA,SAT3B,EAAA;EAAA,SACA,IAAA;;;;;;;cAQmB,MAAA,EAAQ,mBAAA;AAAA"}

package/dist/component/providers/phone.d.ts

@@ -1,6 +1,12 @@
 import { PhoneConfig } from "../server/types.js";
 
 //#region src/providers/phone.d.ts
+/**
+ * User-facing configuration for the {@link Phone} provider.
+ *
+ * Use this to send SMS or other phone-based verification messages during
+ * sign-in.
+ */
 interface PhoneProviderConfig {
   /** Send the verification code to the user's phone. */
   send: PhoneConfig["sendVerificationRequest"];
@@ -9,10 +15,32 @@ interface PhoneProviderConfig {
   /** Token expiration in seconds. Defaults to 1200 (20 minutes). */
   maxAge?: number;
 }
+/**
+ * Phone provider for SMS or phone-number verification flows.
+ *
+ * Wraps your `send()` implementation and materializes the runtime behavior
+ * Convex Auth needs for short-code or magic-link-style phone verification.
+ *
+ * @example
+ * ```ts
+ * import { Phone } from "@robelest/convex-auth/providers";
+ *
+ * const phone = new Phone({
+ *   send: async ({ identifier, token }) => {
+ *     await sms.send({ to: identifier, body: `Your sign-in code is ${token}` });
+ *   },
+ * });
+ * ```
+ */
 declare class Phone {
   readonly config: PhoneProviderConfig;
   readonly id: string;
   readonly type: "phone";
+  /**
+   * Create a phone provider instance.
+   *
+   * @param config - Phone delivery and provider settings.
+   */
   constructor(config: PhoneProviderConfig);
 }
 //#endregion

package/dist/component/providers/phone.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"phone.d.ts","names":[],"sources":["../../../src/providers/phone.ts"],"mappings":";;;UAUiB,mBAAA;EAEf;EAAA,IAAA,EAAM,WAAA;EAEN;EAAA,EAAA;EAEM;EAAN,MAAA;AAAA;AAAA,cAGW,KAAA;EAAA,SAIiB,MAAA,EAAQ,mBAAA;EAAA,SAH3B,EAAA;EAAA,SACA,IAAA;cAEmB,MAAA,EAAQ,mBAAA;AAAA"}
+{"version":3,"file":"phone.d.ts","names":[],"sources":["../../../src/providers/phone.ts"],"mappings":";;;;;;;;;UAgBiB,mBAAA;EA0BJ;EAxBX,IAAA,EAAM,WAAA;;EAEN,EAAA;EA+B4B;EA7B5B,MAAA;AAAA;;;;;;;;;;;;;;;;;;cAoBW,KAAA;EAAA,SASiB,MAAA,EAAQ,mBAAA;EAAA,SAR3B,EAAA;EAAA,SACA,IAAA;;;;;;cAOmB,MAAA,EAAQ,mBAAA;AAAA"}

package/dist/component/public/enterprise/audit.d.ts

@@ -0,0 +1,73 @@
+declare namespace audit_d_exports {
+  export { enterpriseAuditEventCreate, enterpriseAuditEventList };
+}
+/**
+ * Record a new audit event for an enterprise.
+ *
+ * Inserts an immutable audit log entry capturing who performed what action,
+ * on which subject, and whether it succeeded or failed. Use this to maintain
+ * a tamper-evident trail of security-relevant events.
+ *
+ * @param args.enterpriseId - The ID of the enterprise this event belongs to.
+ * @param args.groupId - The ID of the root group that owns the enterprise.
+ * @param args.eventType - A string identifying the type of event (e.g. `"user.login"`, `"scim.provision"`).
+ * @param args.actorType - The kind of actor: `"user"`, `"system"`, `"scim"`, `"api_key"`, or `"webhook"`.
+ * @param args.actorId - An optional identifier for the actor (e.g. a user ID or API key ID).
+ * @param args.subjectType - The type of the resource being acted upon (e.g. `"user"`, `"group"`).
+ * @param args.subjectId - An optional identifier for the subject resource.
+ * @param args.status - Whether the event represents a `"success"` or `"failure"`.
+ * @param args.occurredAt - Epoch timestamp (ms) when the event occurred.
+ * @param args.requestId - An optional correlation ID tying this event to a specific request.
+ * @param args.ip - An optional IP address of the actor.
+ * @param args.metadata - An optional arbitrary object with additional event details.
+ * @returns The ID of the newly created `EnterpriseAuditEvent` document.
+ *
+ * @example
+ * ```ts
+ * const eventId = await ctx.runMutation(
+ *   components.auth.enterprise.enterpriseAuditEventCreate,
+ *   {
+ *     enterpriseId,
+ *     groupId: orgGroupId,
+ *     eventType: "user.login",
+ *     actorType: "user",
+ *     actorId: userId,
+ *     subjectType: "session",
+ *     subjectId: sessionId,
+ *     status: "success",
+ *     occurredAt: Date.now(),
+ *     ip: "203.0.113.42",
+ *   },
+ * );
+ * ```
+ */
+declare const enterpriseAuditEventCreate: any;
+/**
+ * List audit events, optionally filtered by enterprise or group.
+ *
+ * Returns audit events in reverse chronological order. When `enterpriseId` is
+ * provided, events are filtered using the `enterprise_id_occurred_at` index.
+ * When only `groupId` is provided, the `group_id_occurred_at` index is used.
+ * If neither filter is given, the most recent events across all enterprises
+ * are returned.
+ *
+ * @param args.enterpriseId - An optional enterprise ID to scope events to a single enterprise.
+ * @param args.groupId - An optional group ID to scope events to a single group.
+ * @param args.limit - Maximum number of events to return (clamped between 1 and 100, defaults to 50).
+ * @returns An array of audit event documents, most recent first.
+ *
+ * @example
+ * ```ts
+ * const events = await ctx.runQuery(
+ *   components.auth.enterprise.enterpriseAuditEventList,
+ *   { enterpriseId, limit: 20 },
+ * );
+ * for (const event of events) {
+ *   console.log(event.eventType, event.actorType, event.status);
+ * }
+ * ```
+ */
+declare const enterpriseAuditEventList: any;
+//#endregion
+export { audit_d_exports, enterpriseAuditEventCreate, enterpriseAuditEventList };
+//# sourceMappingURL=audit.d.ts.map

package/dist/component/public/enterprise/audit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.d.ts","names":[],"sources":["../../../../src/component/public/enterprise/audit.ts"],"mappings":";;;;;;;;;;AA4CA;;;;;AA8CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA9Ca,0BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;cA8CA,wBAAA"}

package/dist/component/public/enterprise/audit.js

@@ -0,0 +1,108 @@
+import { mutation, query } from "../../functions.js";
+import { vAuditActorType, vAuditStatus, vEnterpriseAuditEventDoc } from "../../model.js";
+import { v } from "convex/values";
+
+//#region src/component/public/enterprise/audit.ts
+/**
+* Record a new audit event for an enterprise.
+*
+* Inserts an immutable audit log entry capturing who performed what action,
+* on which subject, and whether it succeeded or failed. Use this to maintain
+* a tamper-evident trail of security-relevant events.
+*
+* @param args.enterpriseId - The ID of the enterprise this event belongs to.
+* @param args.groupId - The ID of the root group that owns the enterprise.
+* @param args.eventType - A string identifying the type of event (e.g. `"user.login"`, `"scim.provision"`).
+* @param args.actorType - The kind of actor: `"user"`, `"system"`, `"scim"`, `"api_key"`, or `"webhook"`.
+* @param args.actorId - An optional identifier for the actor (e.g. a user ID or API key ID).
+* @param args.subjectType - The type of the resource being acted upon (e.g. `"user"`, `"group"`).
+* @param args.subjectId - An optional identifier for the subject resource.
+* @param args.status - Whether the event represents a `"success"` or `"failure"`.
+* @param args.occurredAt - Epoch timestamp (ms) when the event occurred.
+* @param args.requestId - An optional correlation ID tying this event to a specific request.
+* @param args.ip - An optional IP address of the actor.
+* @param args.metadata - An optional arbitrary object with additional event details.
+* @returns The ID of the newly created `EnterpriseAuditEvent` document.
+*
+* @example
+* ```ts
+* const eventId = await ctx.runMutation(
+*   components.auth.enterprise.enterpriseAuditEventCreate,
+*   {
+*     enterpriseId,
+*     groupId: orgGroupId,
+*     eventType: "user.login",
+*     actorType: "user",
+*     actorId: userId,
+*     subjectType: "session",
+*     subjectId: sessionId,
+*     status: "success",
+*     occurredAt: Date.now(),
+*     ip: "203.0.113.42",
+*   },
+* );
+* ```
+*/
+const enterpriseAuditEventCreate = mutation({
+	args: {
+		enterpriseId: v.id("Enterprise"),
+		groupId: v.id("Group"),
+		eventType: v.string(),
+		actorType: vAuditActorType,
+		actorId: v.optional(v.string()),
+		subjectType: v.string(),
+		subjectId: v.optional(v.string()),
+		status: vAuditStatus,
+		occurredAt: v.number(),
+		requestId: v.optional(v.string()),
+		ip: v.optional(v.string()),
+		metadata: v.optional(v.any())
+	},
+	returns: v.id("EnterpriseAuditEvent"),
+	handler: async (ctx, args) => {
+		return await ctx.db.insert("EnterpriseAuditEvent", args);
+	}
+});
+/**
+* List audit events, optionally filtered by enterprise or group.
+*
+* Returns audit events in reverse chronological order. When `enterpriseId` is
+* provided, events are filtered using the `enterprise_id_occurred_at` index.
+* When only `groupId` is provided, the `group_id_occurred_at` index is used.
+* If neither filter is given, the most recent events across all enterprises
+* are returned.
+*
+* @param args.enterpriseId - An optional enterprise ID to scope events to a single enterprise.
+* @param args.groupId - An optional group ID to scope events to a single group.
+* @param args.limit - Maximum number of events to return (clamped between 1 and 100, defaults to 50).
+* @returns An array of audit event documents, most recent first.
+*
+* @example
+* ```ts
+* const events = await ctx.runQuery(
+*   components.auth.enterprise.enterpriseAuditEventList,
+*   { enterpriseId, limit: 20 },
+* );
+* for (const event of events) {
+*   console.log(event.eventType, event.actorType, event.status);
+* }
+* ```
+*/
+const enterpriseAuditEventList = query({
+	args: {
+		enterpriseId: v.optional(v.id("Enterprise")),
+		groupId: v.optional(v.id("Group")),
+		limit: v.optional(v.number())
+	},
+	returns: v.array(vEnterpriseAuditEventDoc),
+	handler: async (ctx, args) => {
+		const limit = Math.min(Math.max(args.limit ?? 50, 1), 100);
+		if (args.enterpriseId !== void 0) return await ctx.db.query("EnterpriseAuditEvent").withIndex("enterprise_id_occurred_at", (idx) => idx.eq("enterpriseId", args.enterpriseId)).order("desc").take(limit);
+		if (args.groupId !== void 0) return await ctx.db.query("EnterpriseAuditEvent").withIndex("group_id_occurred_at", (idx) => idx.eq("groupId", args.groupId)).order("desc").take(limit);
+		return await ctx.db.query("EnterpriseAuditEvent").order("desc").take(limit);
+	}
+});
+
+//#endregion
+export { enterpriseAuditEventCreate, enterpriseAuditEventList };
+//# sourceMappingURL=audit.js.map

package/dist/component/public/enterprise/audit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.js","names":[],"sources":["../../../../src/component/public/enterprise/audit.ts"],"sourcesContent":["import { v } from \"convex/values\";\nimport { mutation, query } from \"../../functions\";\nimport { vAuditActorType, vAuditStatus, vEnterpriseAuditEventDoc } from \"../../model\";\n\n/**\n * Record a new audit event for an enterprise.\n *\n * Inserts an immutable audit log entry capturing who performed what action,\n * on which subject, and whether it succeeded or failed. Use this to maintain\n * a tamper-evident trail of security-relevant events.\n *\n * @param args.enterpriseId - The ID of the enterprise this event belongs to.\n * @param args.groupId - The ID of the root group that owns the enterprise.\n * @param args.eventType - A string identifying the type of event (e.g. `\"user.login\"`, `\"scim.provision\"`).\n * @param args.actorType - The kind of actor: `\"user\"`, `\"system\"`, `\"scim\"`, `\"api_key\"`, or `\"webhook\"`.\n * @param args.actorId - An optional identifier for the actor (e.g. a user ID or API key ID).\n * @param args.subjectType - The type of the resource being acted upon (e.g. `\"user\"`, `\"group\"`).\n * @param args.subjectId - An optional identifier for the subject resource.\n * @param args.status - Whether the event represents a `\"success\"` or `\"failure\"`.\n * @param args.occurredAt - Epoch timestamp (ms) when the event occurred.\n * @param args.requestId - An optional correlation ID tying this event to a specific request.\n * @param args.ip - An optional IP address of the actor.\n * @param args.metadata - An optional arbitrary object with additional event details.\n * @returns The ID of the newly created `EnterpriseAuditEvent` document.\n *\n * @example\n * ```ts\n * const eventId = await ctx.runMutation(\n *   components.auth.enterprise.enterpriseAuditEventCreate,\n *   {\n *     enterpriseId,\n *     groupId: orgGroupId,\n *     eventType: \"user.login\",\n *     actorType: \"user\",\n *     actorId: userId,\n *     subjectType: \"session\",\n *     subjectId: sessionId,\n *     status: \"success\",\n *     occurredAt: Date.now(),\n *     ip: \"203.0.113.42\",\n *   },\n * );\n * ```\n */\nexport const enterpriseAuditEventCreate = mutation({\n  args: {\n    enterpriseId: v.id(\"Enterprise\"),\n    groupId: v.id(\"Group\"),\n    eventType: v.string(),\n    actorType: vAuditActorType,\n    actorId: v.optional(v.string()),\n    subjectType: v.string(),\n    subjectId: v.optional(v.string()),\n    status: vAuditStatus,\n    occurredAt: v.number(),\n    requestId: v.optional(v.string()),\n    ip: v.optional(v.string()),\n    metadata: v.optional(v.any()),\n  },\n  returns: v.id(\"EnterpriseAuditEvent\"),\n  handler: async (ctx, args) => {\n    return await ctx.db.insert(\"EnterpriseAuditEvent\", args);\n  },\n});\n\n/**\n * List audit events, optionally filtered by enterprise or group.\n *\n * Returns audit events in reverse chronological order. When `enterpriseId` is\n * provided, events are filtered using the `enterprise_id_occurred_at` index.\n * When only `groupId` is provided, the `group_id_occurred_at` index is used.\n * If neither filter is given, the most recent events across all enterprises\n * are returned.\n *\n * @param args.enterpriseId - An optional enterprise ID to scope events to a single enterprise.\n * @param args.groupId - An optional group ID to scope events to a single group.\n * @param args.limit - Maximum number of events to return (clamped between 1 and 100, defaults to 50).\n * @returns An array of audit event documents, most recent first.\n *\n * @example\n * ```ts\n * const events = await ctx.runQuery(\n *   components.auth.enterprise.enterpriseAuditEventList,\n *   { enterpriseId, limit: 20 },\n * );\n * for (const event of events) {\n *   console.log(event.eventType, event.actorType, event.status);\n * }\n * ```\n */\nexport const enterpriseAuditEventList = query({\n  args: {\n    enterpriseId: v.optional(v.id(\"Enterprise\")),\n    groupId: v.optional(v.id(\"Group\")),\n    limit: v.optional(v.number()),\n  },\n  returns: v.array(vEnterpriseAuditEventDoc),\n  handler: async (ctx, args) => {\n    const limit = Math.min(Math.max(args.limit ?? 50, 1), 100);\n    if (args.enterpriseId !== undefined) {\n      return await ctx.db\n        .query(\"EnterpriseAuditEvent\")\n        .withIndex(\"enterprise_id_occurred_at\", (idx) =>\n          idx.eq(\"enterpriseId\", args.enterpriseId!),\n        )\n        .order(\"desc\")\n        .take(limit);\n    }\n    if (args.groupId !== undefined) {\n      return await ctx.db\n        .query(\"EnterpriseAuditEvent\")\n        .withIndex(\"group_id_occurred_at\", (idx) =>\n          idx.eq(\"groupId\", args.groupId!),\n        )\n        .order(\"desc\")\n        .take(limit);\n    }\n    return await ctx.db.query(\"EnterpriseAuditEvent\").order(\"desc\").take(limit);\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,MAAa,6BAA6B,SAAS;CACjD,MAAM;EACJ,cAAc,EAAE,GAAG,aAAa;EAChC,SAAS,EAAE,GAAG,QAAQ;EACtB,WAAW,EAAE,QAAQ;EACrB,WAAW;EACX,SAAS,EAAE,SAAS,EAAE,QAAQ,CAAC;EAC/B,aAAa,EAAE,QAAQ;EACvB,WAAW,EAAE,SAAS,EAAE,QAAQ,CAAC;EACjC,QAAQ;EACR,YAAY,EAAE,QAAQ;EACtB,WAAW,EAAE,SAAS,EAAE,QAAQ,CAAC;EACjC,IAAI,EAAE,SAAS,EAAE,QAAQ,CAAC;EAC1B,UAAU,EAAE,SAAS,EAAE,KAAK,CAAC;EAC9B;CACD,SAAS,EAAE,GAAG,uBAAuB;CACrC,SAAS,OAAO,KAAK,SAAS;AAC5B,SAAO,MAAM,IAAI,GAAG,OAAO,wBAAwB,KAAK;;CAE3D,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BF,MAAa,2BAA2B,MAAM;CAC5C,MAAM;EACJ,cAAc,EAAE,SAAS,EAAE,GAAG,aAAa,CAAC;EAC5C,SAAS,EAAE,SAAS,EAAE,GAAG,QAAQ,CAAC;EAClC,OAAO,EAAE,SAAS,EAAE,QAAQ,CAAC;EAC9B;CACD,SAAS,EAAE,MAAM,yBAAyB;CAC1C,SAAS,OAAO,KAAK,SAAS;EAC5B,MAAM,QAAQ,KAAK,IAAI,KAAK,IAAI,KAAK,SAAS,IAAI,EAAE,EAAE,IAAI;AAC1D,MAAI,KAAK,iBAAiB,OACxB,QAAO,MAAM,IAAI,GACd,MAAM,uBAAuB,CAC7B,UAAU,8BAA8B,QACvC,IAAI,GAAG,gBAAgB,KAAK,aAAc,CAC3C,CACA,MAAM,OAAO,CACb,KAAK,MAAM;AAEhB,MAAI,KAAK,YAAY,OACnB,QAAO,MAAM,IAAI,GACd,MAAM,uBAAuB,CAC7B,UAAU,yBAAyB,QAClC,IAAI,GAAG,WAAW,KAAK,QAAS,CACjC,CACA,MAAM,OAAO,CACb,KAAK,MAAM;AAEhB,SAAO,MAAM,IAAI,GAAG,MAAM,uBAAuB,CAAC,MAAM,OAAO,CAAC,KAAK,MAAM;;CAE9E,CAAC"}

package/dist/component/public/enterprise/core.d.ts

@@ -0,0 +1,176 @@
+declare namespace core_d_exports {
+  export { enterpriseCreate, enterpriseDelete, enterpriseGet, enterpriseGetByDomain, enterpriseGetByGroup, enterpriseList, enterpriseUpdate };
+}
+/**
+ * Create a new enterprise record attached to a root group.
+ *
+ * Each group may only have one enterprise record. If an enterprise already
+ * exists for the given group, a `ENTERPRISE_ALREADY_EXISTS` error is thrown.
+ * The enterprise status defaults to `"draft"` when not explicitly provided.
+ *
+ * @param args.groupId - The ID of the root group that owns this enterprise.
+ * @param args.slug - An optional URL-friendly identifier for the enterprise.
+ * @param args.name - An optional human-readable display name for the enterprise.
+ * @param args.status - The lifecycle status (`"draft"`, `"active"`, or `"disabled"`). Defaults to `"draft"`.
+ * @param args.policy - An optional enterprise policy object controlling identity linking, provisioning, and deprovisioning behavior.
+ * @param args.config - An optional arbitrary configuration blob for enterprise-specific settings.
+ * @param args.extend - An optional arbitrary extension object for custom fields.
+ * @returns The ID of the newly created `Enterprise` document.
+ *
+ * @example
+ * ```ts
+ * const enterpriseId = await ctx.runMutation(
+ *   components.auth.enterprise.enterpriseCreate,
+ *   {
+ *     groupId: orgGroupId,
+ *     slug: "acme-corp",
+ *     name: "Acme Corporation",
+ *     status: "active",
+ *   },
+ * );
+ * ```
+ */
+declare const enterpriseCreate: any;
+/**
+ * Retrieve a single enterprise record by its document ID.
+ *
+ * Returns the full enterprise document if it exists, or `null` if no
+ * enterprise is found with the given ID.
+ *
+ * @param args.enterpriseId - The document ID of the enterprise to retrieve.
+ * @returns The enterprise document, or `null` if not found.
+ *
+ * @example
+ * ```ts
+ * const enterprise = await ctx.runQuery(
+ *   components.auth.enterprise.enterpriseGet,
+ *   { enterpriseId },
+ * );
+ * if (enterprise) {
+ *   console.log(enterprise.name, enterprise.status);
+ * }
+ * ```
+ */
+declare const enterpriseGet: any;
+/**
+ * Retrieve an enterprise record by the ID of its owning group.
+ *
+ * Looks up the enterprise that is linked to the specified group using the
+ * `group_id` index. Returns `null` if no enterprise is associated with the group.
+ *
+ * @param args.groupId - The ID of the root group whose enterprise record to look up.
+ * @returns The enterprise document, or `null` if the group has no enterprise.
+ *
+ * @example
+ * ```ts
+ * const enterprise = await ctx.runQuery(
+ *   components.auth.enterprise.enterpriseGetByGroup,
+ *   { groupId: orgGroupId },
+ * );
+ * ```
+ */
+declare const enterpriseGetByGroup: any;
+/**
+ * Retrieve an enterprise record by one of its linked domain names.
+ *
+ * Looks up an `EnterpriseDomain` row matching the given domain string, then
+ * resolves the parent enterprise. Returns both the enterprise and the matched
+ * domain document, or `null` if the domain is not registered or its enterprise
+ * no longer exists.
+ *
+ * @param args.domain - The domain name to search for (e.g. `"acme.com"`).
+ * @returns An object containing the `enterprise` and `domain` documents, or `null` if not found.
+ *
+ * @example
+ * ```ts
+ * const result = await ctx.runQuery(
+ *   components.auth.enterprise.enterpriseGetByDomain,
+ *   { domain: "acme.com" },
+ * );
+ * if (result) {
+ *   console.log(result.enterprise.name, result.domain.verifiedAt);
+ * }
+ * ```
+ */
+declare const enterpriseGetByDomain: any;
+/**
+ * List enterprise records with optional filtering and cursor-based pagination.
+ *
+ * Supports filtering by `groupId`, `slug`, and/or `status`. The query selects
+ * the most specific index available for the primary filter, then applies
+ * remaining predicates as post-filters. Results are ordered by creation time
+ * (or the specified field) and paginated using an opaque cursor.
+ *
+ * @param args.where - Optional filter criteria: `groupId`, `slug`, and/or `status`.
+ * @param args.limit - Maximum number of items per page (clamped between 1 and 100, defaults to 50).
+ * @param args.cursor - An opaque cursor string returned from a previous call to fetch the next page, or `null` / omitted for the first page.
+ * @param args.orderBy - The field to sort results by: `"_creationTime"`, `"name"`, `"slug"`, or `"status"`.
+ * @param args.order - Sort direction: `"asc"` or `"desc"` (defaults to `"desc"`).
+ * @returns A paginated result containing `items` (array of enterprise documents) and `nextCursor` (`string | null`).
+ *
+ * @example
+ * ```ts
+ * const page = await ctx.runQuery(
+ *   components.auth.enterprise.enterpriseList,
+ *   {
+ *     where: { status: "active" },
+ *     limit: 25,
+ *     order: "asc",
+ *   },
+ * );
+ * for (const ent of page.items) {
+ *   console.log(ent.name);
+ * }
+ * // Fetch next page:
+ * const nextPage = await ctx.runQuery(
+ *   components.auth.enterprise.enterpriseList,
+ *   { where: { status: "active" }, cursor: page.nextCursor },
+ * );
+ * ```
+ */
+declare const enterpriseList: any;
+/**
+ * Partially update (patch) an existing enterprise record.
+ *
+ * Merges the provided `data` fields into the existing enterprise document.
+ * Only the fields present in `data` are changed; all other fields are preserved.
+ *
+ * @param args.enterpriseId - The document ID of the enterprise to update.
+ * @param args.data - An object containing the fields to update (e.g. `{ name, status, policy }`).
+ * @returns `null` on success.
+ *
+ * @example
+ * ```ts
+ * await ctx.runMutation(
+ *   components.auth.enterprise.enterpriseUpdate,
+ *   {
+ *     enterpriseId,
+ *     data: { status: "active", name: "Acme Corp (Renamed)" },
+ *   },
+ * );
+ * ```
+ */
+declare const enterpriseUpdate: any;
+/**
+ * Delete an enterprise record and all of its associated child data.
+ *
+ * This cascading delete removes the enterprise document along with all linked
+ * domain records, domain verification records, and enterprise secrets. Callers
+ * should ensure that higher-level cleanup (e.g. SCIM identities, webhook
+ * endpoints) is handled separately if needed.
+ *
+ * @param args.enterpriseId - The document ID of the enterprise to delete.
+ * @returns `null` on success.
+ *
+ * @example
+ * ```ts
+ * await ctx.runMutation(
+ *   components.auth.enterprise.enterpriseDelete,
+ *   { enterpriseId },
+ * );
+ * ```
+ */
+declare const enterpriseDelete: any;
+//#endregion
+export { core_d_exports, enterpriseCreate, enterpriseDelete, enterpriseGet, enterpriseGetByDomain, enterpriseGetByGroup, enterpriseList, enterpriseUpdate };
+//# sourceMappingURL=core.d.ts.map

package/dist/component/public/enterprise/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","names":[],"sources":["../../../../src/component/public/enterprise/core.ts"],"mappings":";;;;;;;;;;;;;;;AAuCA;;;;;AAiDA;;;;;AAyBA;;;;;AAiCA;;cA3Ga,gBAAA;;;AAuKb;;;;;AA2FA;;;;;AA4BA;;;;;;;;cA7Oa,aAAA;;;;;;;;;;;;;;;;;;cAyBA,oBAAA;;;;;;;;;;;;;;;;;;;;;;;cAiCA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4DA,cAAA;;;;;;;;;;;;;;;;;;;;;;cA2FA,gBAAA;;;;;;;;;;;;;;;;;;;;cA4BA,gBAAA"}