@robelest/convex-auth 0.0.4-preview.25 → 0.0.4-preview.28

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

@@ -1 +0,0 @@
-{"version":3,"file":"passkey.d.ts","names":[],"sources":["../../../src/providers/passkey.ts"],"mappings":";;AAiBA;;;;;;;;;;;;;UAAiB,aAAA;EAkBM;EAhBrB,MAAA;EAgCkB;EA9BlB,IAAA;EAmCsC;EAjCtC,MAAA;EA8BS;EA5BT,WAAA;EA6BiB;EA3BjB,gBAAA;EA6BoB;EA3BpB,WAAA;EA2BsC;EAzBtC,uBAAA;;EAEA,UAAA;;EAEA,qBAAA;AAAA;;;;;;;;;;;;;;cAgBW,OAAA;EAAA,SACF,EAAA;EAAA,SACA,IAAA;EAAA,SACA,MAAA,EAAQ,aAAA;cAEL,MAAA,GAAQ,aAAA;AAAA"}

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

@@ -1,88 +0,0 @@
-import { CredentialsConfig } from "./credentials.js";
-import { EmailConfig, GenericActionCtxWithAuthConfig } from "../server/types.js";
-import { DocumentByName, GenericDataModel, WithoutSystemFields } from "convex/server";
-import { Value } from "convex/values";
-
-//#region src/providers/password.d.ts
-/**
- * The available options to a {@link Password} provider for Convex Auth.
- */
-interface PasswordConfig<DataModel extends GenericDataModel> {
-  /**
-   * Uniquely identifies the provider, allowing to use
-   * multiple different {@link Password} providers.
-   */
-  id?: string;
-  /**
-   * Perform checks on provided params and customize the user
-   * information stored after sign up, including email normalization.
-   *
-   * Called for every flow ("signUp", "signIn", "reset",
-   * "reset-verification" and "email-verification").
-   */
-  profile?: (
-  /**
-   * The values passed to the `signIn` function.
-   */
-  params: Record<string, Value | undefined>,
-  /**
-   * Convex ActionCtx in case you want to read from or write to
-   * the database.
-   */
-  ctx: GenericActionCtxWithAuthConfig<DataModel>) => WithoutSystemFields<DocumentByName<DataModel, "User">> & {
-    email: string;
-  };
-  /**
-   * Performs custom validation on password provided during sign up or reset.
-   *
-   * Otherwise the default validation is used (password is not empty and
-   * at least 8 characters in length).
-   *
-   * If the provided password is invalid, implementations must throw an Error.
-   *
-   * @param password the password supplied during "signUp" or
-   *                 "reset-verification" flows.
-   */
-  validatePasswordRequirements?: (password: string) => void;
-  /**
-   * Provide hashing and verification functions if you want to control
-   * how passwords are hashed.
-   */
-  crypto?: CredentialsConfig["crypto"];
-  /**
-   * An email provider used to require verification
-   * before password reset.
-   */
-  reset?: EmailConfig | ((...args: any) => EmailConfig);
-  /**
-   * An email provider used to require verification
-   * before sign up / sign in.
-   */
-  verify?: EmailConfig | ((...args: any) => EmailConfig);
-}
-/**
- * Email and password authentication provider.
- *
- * Passwords are by default hashed using scrypt.
- * You can customize the hashing via the `crypto` option.
- *
- * Email verification is not required unless you pass
- * an email provider to the `verify` option.
- *
- * @example
- * ```ts
- * import { Password } from "@robelest/convex-auth/providers";
- *
- * new Password()
- * new Password({ verify: myEmailProvider })
- * ```
- */
-declare class Password<DataModel extends GenericDataModel = GenericDataModel> {
-  readonly id: string;
-  readonly type: "credentials";
-  readonly config: PasswordConfig<DataModel>;
-  constructor(config?: PasswordConfig<DataModel>);
-}
-//#endregion
-export { Password };
-//# sourceMappingURL=password.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"password.d.ts","names":[],"sources":["../../../src/providers/password.ts"],"mappings":";;;;;;;;;UA4CiB,cAAA,mBAAiC,gBAAA;EAiBvB;;;;EAZzB,EAAA;EAkBK;;;;;;;EAVL,OAAA;EAkCA;;;EA9BE,MAAA,EAAQ,MAAA,SAAe,KAAA;EAmCzB;;;;EA9BE,GAAA,EAAK,8BAAA,CAA+B,SAAA,MACjC,mBAAA,CAAoB,cAAA,CAAe,SAAA;IACtC,KAAA;EAAA;EA2EiB;;;;;;;;;;;EA9DnB,4BAAA,IAAgC,QAAA;EA8DyB;;;;EAzDzD,MAAA,GAAS,iBAAA;EA4DuB;;;;EAvDhC,KAAA,GAAQ,WAAA,QAAmB,IAAA,UAAc,WAAA;EA0D4B;;;;EArDrE,MAAA,GAAS,WAAA,QAAmB,IAAA,UAAc,WAAA;AAAA;;;;;;;;;;;;;;;;;;cA+C/B,QAAA,mBAA2B,gBAAA,GAAmB,gBAAA;EAAA,SAChD,EAAA;EAAA,SACA,IAAA;EAAA,SACA,MAAA,EAAQ,cAAA,CAAe,SAAA;cAG9B,MAAA,GAAQ,cAAA,CAAe,SAAA;AAAA"}

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

@@ -1,48 +0,0 @@
-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"];
-  /** Provider ID override. Defaults to "phone". */
-  id?: string;
-  /** 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
-export { Phone };
-//# sourceMappingURL=phone.d.ts.map

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

@@ -1 +0,0 @@
-{"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/providers/sso.d.ts

@@ -1,50 +0,0 @@
-//#region src/providers/sso.d.ts
-/**
- * Enterprise SSO provider (OIDC + SAML + SCIM).
- *
- * Adding `new SSO()` to your providers list enables enterprise SSO
- * sign-in flows and registers the OIDC, SAML, and SCIM runtime HTTP
- * routes. It also makes `auth.sso.*` available on the auth
- * object returned by `createAuth`.
- *
- * ```ts
- * import { SSO } from "@robelest/convex-auth/providers";
- *
- * const auth = createAuth(components.auth, {
- *   providers: [new SSO(), new Password()],
- * });
- *
- * // auth.sso is now available
- * await auth.sso.admin.oidc.configure(ctx, { enterpriseId, clientId, ... });
- * ```
- *
- * Without `new SSO()` in the providers list, `auth.sso` is not
- * present on the returned object and accessing it is a TypeScript error.
- *
- * @module
- */
-/**
- * Enterprise SSO provider.
- *
- * Zero-configuration — sensible defaults are applied for all enterprise
- * protocols (OIDC, SAML, SCIM). Per-tenant configuration is done at
- * runtime via `auth.sso.*` helpers.
- *
- * @example
- * ```ts
- * import { createAuth } from "@robelest/convex-auth/component";
- * import { SSO, Password } from "@robelest/convex-auth/providers";
- * import { components } from "./_generated/api";
- *
- * export const auth = createAuth(components.auth, {
- *   providers: [new SSO(), new Password()],
- * });
- * ```
- */
-declare class SSO {
-  readonly id = "enterprise-sso";
-  readonly type: "sso";
-}
-//#endregion
-export { SSO };
-//# sourceMappingURL=sso.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sso.d.ts","names":[],"sources":["../../../src/providers/sso.ts"],"mappings":";;AA6CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,GAAA;EAAA,SACF,EAAA;EAAA,SACA,IAAA;AAAA"}

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

@@ -1,45 +0,0 @@
-//#region src/providers/totp.d.ts
-/**
- * TOTP (Time-based One-Time Password) two-factor authentication provider.
- *
- * ```ts
- * import { Totp } from "@robelest/convex-auth/providers";
- *
- * new Totp({ issuer: "My App" })
- * ```
- *
- * @module
- */
-/**
- * Configuration for the TOTP provider.
- */
-interface TotpConfig {
-  /** Issuer name shown in authenticator apps (e.g. "My App"). */
-  issuer?: string;
-  /** Number of digits in each code (default: 6). */
-  digits?: number;
-  /** Time period in seconds for code rotation (default: 30). */
-  period?: number;
-}
-/**
- * TOTP (Time-based One-Time Password) two-factor authentication provider.
- *
- * Generates time-based one-time passwords compatible with authenticator
- * apps like Google Authenticator and Authy.
- *
- * @example
- * ```ts
- * import { Totp } from "@robelest/convex-auth/providers";
- *
- * new Totp({ issuer: "My App" })
- * ```
- */
-declare class Totp {
-  readonly id: string;
-  readonly type: "totp";
-  readonly config: TotpConfig;
-  constructor(config?: TotpConfig);
-}
-//#endregion
-export { Totp };
-//# sourceMappingURL=totp.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"totp.d.ts","names":[],"sources":["../../../src/providers/totp.ts"],"mappings":";;AAiBA;;;;;;;;;AAsBA;;;;UAtBiB,UAAA;EAwBN;EAtBT,MAAA;EAuBiB;EArBjB,MAAA;EAuBoB;EArBpB,MAAA;AAAA;;;;;;;;;;;;;;cAgBW,IAAA;EAAA,SACF,EAAA;EAAA,SACA,IAAA;EAAA,SACA,MAAA,EAAQ,UAAA;cAEL,MAAA,GAAQ,UAAA;AAAA"}

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

@@ -1,73 +0,0 @@
-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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"audit.js","names":[],"sources":["../../../../src/component/public/enterprise/audit.ts"],"sourcesContent":["import { v } from \"convex/values\";\n\nimport { mutation, query } from \"../../functions\";\nimport {\n  vAuditActorType,\n  vAuditStatus,\n  vEnterpriseAuditEventDoc,\n} 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,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

@@ -1,176 +0,0 @@
-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

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