@banata-auth/shared 0.1.0

package/dist/index.cjs

@@ -0,0 +1,788 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/constants.ts
+var ID_PREFIXES = {
+  user: "usr",
+  session: "ses",
+  account: "acc",
+  organization: "org",
+  organizationMember: "mem",
+  organizationInvitation: "inv",
+  team: "team",
+  ssoConnection: "conn",
+  ssoProfile: "prof",
+  directory: "dir",
+  directoryUser: "diru",
+  directoryGroup: "dirg",
+  auditEvent: "evt",
+  event: "event",
+  webhookEndpoint: "wh",
+  webhookDelivery: "whd",
+  apiKey: "ak",
+  role: "role",
+  vaultSecret: "vsec",
+  domainVerification: "dv",
+  fgaTuple: "fga",
+  radarEvent: "radar",
+  project: "proj",
+  environment: "env",
+  emailTemplate: "etpl"
+};
+var RATE_LIMITS = {
+  general: 600,
+  signIn: 30,
+  signUp: 10,
+  passwordReset: 10,
+  emailOperations: 10,
+  scim: 100,
+  admin: 120,
+  webhookDelivery: 0
+  // No limit (outbound)
+};
+var TOKEN_LIFETIMES = {
+  /** JWT access token: 15 minutes */
+  accessToken: 15 * 60,
+  /** Session record: 7 days */
+  session: 7 * 24 * 60 * 60,
+  /** Session absolute max: 30 days */
+  sessionAbsoluteMax: 30 * 24 * 60 * 60,
+  /** Password reset token: 1 hour */
+  passwordReset: 60 * 60,
+  /** Email verification token: 24 hours */
+  emailVerification: 24 * 60 * 60,
+  /** Magic link: 10 minutes */
+  magicLink: 10 * 60,
+  /** Email OTP: 10 minutes */
+  emailOtp: 10 * 60,
+  /** Admin portal link (short-lived): 5 minutes */
+  adminPortalShort: 5 * 60,
+  /** Admin portal link (long-lived): 30 days */
+  adminPortalLong: 30 * 24 * 60 * 60,
+  /** Organization invitation: 7 days */
+  invitation: 7 * 24 * 60 * 60,
+  /** JWKS key rotation: 90 days */
+  jwksRotation: 90 * 24 * 60 * 60
+};
+var SIZE_LIMITS = {
+  /** Max custom metadata size in bytes */
+  metadataMaxBytes: 16 * 1024,
+  // 16KB
+  /** Max SAML response size in bytes */
+  samlMaxBytes: 256 * 1024,
+  // 256KB
+  /** Max SAML XML depth */
+  samlMaxDepth: 50,
+  /** Max webhook payload size in bytes */
+  webhookMaxBytes: 256 * 1024,
+  // 256KB
+  /** Max webhook response body stored (bytes) */
+  webhookResponseMaxBytes: 10 * 1024,
+  // 10KB
+  /** Max SCIM request body size in bytes */
+  scimMaxBytes: 1024 * 1024,
+  // 1MB
+  /** Max password length */
+  passwordMaxLength: 128,
+  /** Min password length */
+  passwordMinLength: 8,
+  /** Max FGA hierarchy depth */
+  fgaMaxDepth: 10
+};
+var WEBHOOK_RETRY_DELAYS = [
+  0,
+  // Attempt 1: immediate
+  5 * 60 * 1e3,
+  // Attempt 2: 5 minutes
+  30 * 60 * 1e3,
+  // Attempt 3: 30 minutes
+  2 * 60 * 60 * 1e3,
+  // Attempt 4: 2 hours
+  24 * 60 * 60 * 1e3
+  // Attempt 5: 24 hours
+];
+var WEBHOOK_MAX_CONSECUTIVE_FAILURES = 3;
+var WEBHOOK_MAX_ATTEMPTS = 5;
+
+// src/id.ts
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var ENCODING_LEN = ENCODING.length;
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
+function encodeTime(now, len) {
+  let str = "";
+  let remaining = now;
+  for (let i = len; i > 0; i--) {
+    const mod = remaining % ENCODING_LEN;
+    str = ENCODING[mod] + str;
+    remaining = (remaining - mod) / ENCODING_LEN;
+  }
+  return str;
+}
+function encodeRandom(len) {
+  let str = "";
+  const bytes = new Uint8Array(len);
+  crypto.getRandomValues(bytes);
+  for (let i = 0; i < len; i++) {
+    str += ENCODING[bytes[i] % ENCODING_LEN];
+  }
+  return str;
+}
+function ulid() {
+  const now = Date.now();
+  return encodeTime(now, TIME_LEN) + encodeRandom(RANDOM_LEN);
+}
+function generateId(resourceType) {
+  const prefix = ID_PREFIXES[resourceType];
+  return `${prefix}_${ulid()}`;
+}
+function getResourceType(id) {
+  const underscoreIndex = id.indexOf("_");
+  if (underscoreIndex === -1) return null;
+  const prefix = id.slice(0, underscoreIndex);
+  const entry = Object.entries(ID_PREFIXES).find(([, v]) => v === prefix);
+  return entry ? entry[0] : null;
+}
+function validateId(id, expectedType) {
+  const prefix = ID_PREFIXES[expectedType];
+  return id.startsWith(`${prefix}_`);
+}
+function generateRandomToken(byteLength = 32) {
+  const bytes = new Uint8Array(byteLength);
+  crypto.getRandomValues(bytes);
+  const base64 = btoa(String.fromCharCode(...bytes));
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function generateOtp(length = 6) {
+  const bytes = new Uint8Array(length);
+  crypto.getRandomValues(bytes);
+  let otp = "";
+  for (let i = 0; i < length; i++) {
+    otp += (bytes[i] % 10).toString();
+  }
+  return otp;
+}
+
+// src/errors.ts
+var BanataAuthError = class extends Error {
+  status;
+  code;
+  requestId;
+  retryable;
+  constructor(options) {
+    super(options.message);
+    this.name = "BanataAuthError";
+    this.status = options.status;
+    this.code = options.code;
+    this.requestId = options.requestId ?? "";
+    this.retryable = options.retryable ?? false;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      status: this.status,
+      code: this.code,
+      requestId: this.requestId
+    };
+  }
+};
+var AuthenticationError = class extends BanataAuthError {
+  constructor(options = {}) {
+    super({
+      message: options.message ?? "Authentication required",
+      status: 401,
+      code: "authentication_required",
+      requestId: options.requestId,
+      retryable: false
+    });
+    this.name = "AuthenticationError";
+  }
+};
+var ForbiddenError = class extends BanataAuthError {
+  constructor(options = {}) {
+    super({
+      message: options.message ?? "Insufficient permissions",
+      status: 403,
+      code: "forbidden",
+      requestId: options.requestId,
+      retryable: false
+    });
+    this.name = "ForbiddenError";
+  }
+};
+var NotFoundError = class extends BanataAuthError {
+  constructor(options = {}) {
+    super({
+      message: options.message ?? (options.resource ? `${options.resource} not found` : "Not found"),
+      status: 404,
+      code: "not_found",
+      requestId: options.requestId,
+      retryable: false
+    });
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends BanataAuthError {
+  constructor(options = {}) {
+    super({
+      message: options.message ?? "Resource already exists",
+      status: 409,
+      code: "conflict",
+      requestId: options.requestId,
+      retryable: false
+    });
+    this.name = "ConflictError";
+  }
+};
+var ValidationError = class extends BanataAuthError {
+  errors;
+  constructor(options) {
+    super({
+      message: options.message ?? "Validation failed",
+      status: 422,
+      code: "validation_error",
+      requestId: options.requestId,
+      retryable: false
+    });
+    this.name = "ValidationError";
+    this.errors = options.errors;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      errors: this.errors
+    };
+  }
+};
+var RateLimitError = class extends BanataAuthError {
+  retryAfter;
+  constructor(options) {
+    super({
+      message: `Rate limit exceeded. Retry after ${options.retryAfter} seconds`,
+      status: 429,
+      code: "rate_limit_exceeded",
+      requestId: options.requestId,
+      retryable: true
+    });
+    this.name = "RateLimitError";
+    this.retryAfter = options.retryAfter;
+  }
+};
+var InternalError = class extends BanataAuthError {
+  constructor(options = {}) {
+    super({
+      message: options.message ?? "Internal server error",
+      status: 500,
+      code: "internal_error",
+      requestId: options.requestId,
+      retryable: true
+    });
+    this.name = "InternalError";
+  }
+};
+function createErrorFromStatus(status, body, requestId) {
+  switch (status) {
+    case 401:
+      return new AuthenticationError({ message: body.message, requestId });
+    case 403:
+      return new ForbiddenError({ message: body.message, requestId });
+    case 404:
+      return new NotFoundError({ message: body.message, requestId });
+    case 409:
+      return new ConflictError({ message: body.message, requestId });
+    case 422:
+      return new ValidationError({
+        message: body.message,
+        errors: body.errors ?? [],
+        requestId
+      });
+    case 429: {
+      return new RateLimitError({ retryAfter: 60, requestId });
+    }
+    default:
+      if (status >= 500) {
+        return new InternalError({ message: body.message, requestId });
+      }
+      return new BanataAuthError({
+        message: body.message ?? "Unknown error",
+        status,
+        code: body.code ?? "unknown_error",
+        requestId
+      });
+  }
+}
+var emailSchema = zod.z.string().email("Invalid email address").max(255).toLowerCase().trim();
+var passwordSchema = zod.z.string().min(SIZE_LIMITS.passwordMinLength, `Password must be at least ${SIZE_LIMITS.passwordMinLength} characters`).max(SIZE_LIMITS.passwordMaxLength, `Password must be at most ${SIZE_LIMITS.passwordMaxLength} characters`);
+var nameSchema = zod.z.string().trim().min(1, "Name is required").max(255);
+var slugSchema = zod.z.string().min(2, "Slug must be at least 2 characters").max(128).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/, "Slug must be lowercase alphanumeric with hyphens").trim();
+var urlSchema = zod.z.string().url("Invalid URL").max(2048);
+var httpsUrlSchema = urlSchema.refine((url) => url.startsWith("https://"), {
+  message: "URL must use HTTPS"
+});
+var metadataSchema = zod.z.record(zod.z.unknown()).refine((data) => JSON.stringify(data).length <= SIZE_LIMITS.metadataMaxBytes, {
+  message: `Metadata must be less than ${SIZE_LIMITS.metadataMaxBytes / 1024}KB`
+}).optional();
+var domainSchema = zod.z.string().trim().toLowerCase().min(3).max(255).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*\.[a-z]{2,}$/, {
+  message: "Invalid domain format"
+});
+var paginationSchema = zod.z.object({
+  limit: zod.z.coerce.number().int().min(1).max(100).default(10),
+  before: zod.z.string().optional(),
+  after: zod.z.string().optional(),
+  order: zod.z.enum(["asc", "desc"]).default("desc")
+});
+var createUserSchema = zod.z.object({
+  email: emailSchema,
+  password: passwordSchema.optional(),
+  name: nameSchema,
+  image: urlSchema.optional(),
+  username: zod.z.string().min(2).max(64).optional(),
+  phoneNumber: zod.z.string().optional(),
+  emailVerified: zod.z.boolean().default(false),
+  role: zod.z.enum(["user", "admin"]).default("user"),
+  metadata: metadataSchema
+});
+var updateUserSchema = zod.z.object({
+  name: nameSchema.optional(),
+  image: urlSchema.optional().nullable(),
+  username: zod.z.string().min(2).max(64).optional(),
+  phoneNumber: zod.z.string().optional().nullable(),
+  metadata: metadataSchema
+});
+var createOrganizationSchema = zod.z.object({
+  name: nameSchema,
+  slug: slugSchema.optional(),
+  logo: urlSchema.optional(),
+  metadata: metadataSchema,
+  requireMfa: zod.z.boolean().default(false),
+  allowedEmailDomains: zod.z.array(domainSchema).optional(),
+  maxMembers: zod.z.number().int().positive().optional()
+});
+var updateOrganizationSchema = zod.z.object({
+  name: nameSchema.optional(),
+  slug: slugSchema.optional(),
+  logo: urlSchema.optional().nullable(),
+  metadata: metadataSchema,
+  requireMfa: zod.z.boolean().optional(),
+  ssoEnforced: zod.z.boolean().optional(),
+  allowedEmailDomains: zod.z.array(domainSchema).optional().nullable(),
+  maxMembers: zod.z.number().int().positive().optional().nullable()
+});
+var inviteMemberSchema = zod.z.object({
+  email: emailSchema,
+  role: zod.z.string().min(1)
+});
+var createSsoConnectionSchema = zod.z.object({
+  organizationId: zod.z.string(),
+  type: zod.z.enum(["saml", "oidc"]),
+  name: nameSchema,
+  domains: zod.z.array(domainSchema).min(1),
+  samlConfig: zod.z.object({
+    idpEntityId: zod.z.string(),
+    idpSsoUrl: urlSchema,
+    idpCertificate: zod.z.string().min(1),
+    nameIdFormat: zod.z.string().optional(),
+    signRequest: zod.z.boolean().default(false),
+    allowIdpInitiated: zod.z.boolean().default(false),
+    attributeMapping: zod.z.record(zod.z.string()).optional()
+  }).optional(),
+  oidcConfig: zod.z.object({
+    issuer: urlSchema,
+    clientId: zod.z.string().min(1),
+    clientSecret: zod.z.string().min(1),
+    scopes: zod.z.array(zod.z.string()).default(["openid", "email", "profile"])
+  }).optional()
+});
+var createWebhookEndpointSchema = zod.z.object({
+  url: httpsUrlSchema,
+  eventTypes: zod.z.array(zod.z.string()).default([]),
+  enabled: zod.z.boolean().default(true)
+});
+var createAuditEventSchema = zod.z.object({
+  action: zod.z.string().min(1),
+  actor: zod.z.object({
+    type: zod.z.enum(["user", "admin", "system", "api_key", "scim"]),
+    id: zod.z.string(),
+    name: zod.z.string().optional(),
+    email: zod.z.string().optional(),
+    metadata: zod.z.record(zod.z.string()).optional()
+  }),
+  targets: zod.z.array(
+    zod.z.object({
+      type: zod.z.string(),
+      id: zod.z.string(),
+      name: zod.z.string().optional(),
+      metadata: zod.z.record(zod.z.string()).optional()
+    })
+  ).default([]),
+  context: zod.z.object({
+    organizationId: zod.z.string().optional(),
+    ipAddress: zod.z.string().optional(),
+    userAgent: zod.z.string().optional(),
+    requestId: zod.z.string().optional()
+  }).default({}),
+  changes: zod.z.object({
+    before: zod.z.record(zod.z.unknown()).optional(),
+    after: zod.z.record(zod.z.unknown()).optional()
+  }).optional(),
+  idempotencyKey: zod.z.string().optional(),
+  metadata: zod.z.record(zod.z.string()).optional(),
+  occurredAt: zod.z.number().optional()
+});
+
+// src/runtime-auth-config.ts
+function listEnabledSocialProviderIds(config) {
+  if (!config) return [];
+  return Object.entries(config.socialProviders).filter(([, provider]) => provider.enabled).map(([providerId]) => providerId);
+}
+
+// src/email-blocks.ts
+var BLOCK_PALETTE = [
+  { type: "heading", label: "Heading", description: "Title or section heading", icon: "Heading" },
+  {
+    type: "text",
+    label: "Text",
+    description: "Paragraph of body text",
+    icon: "AlignLeft"
+  },
+  {
+    type: "button",
+    label: "Button",
+    description: "Call-to-action button link",
+    icon: "MousePointerClick"
+  },
+  {
+    type: "image",
+    label: "Image",
+    description: "Inline image",
+    icon: "Image"
+  },
+  {
+    type: "divider",
+    label: "Divider",
+    description: "Horizontal separator line",
+    icon: "Minus"
+  },
+  {
+    type: "spacer",
+    label: "Spacer",
+    description: "Empty vertical space",
+    icon: "Space"
+  },
+  {
+    type: "code",
+    label: "Code",
+    description: "Monospace code or OTP display",
+    icon: "Code"
+  },
+  {
+    type: "link",
+    label: "Link",
+    description: "Inline hyperlink",
+    icon: "Link"
+  },
+  {
+    type: "columns",
+    label: "Columns",
+    description: "Multi-column layout (2\u20134)",
+    icon: "Columns2"
+  }
+];
+function makeId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `blk_${Array.from({ length: 12 }, () => Math.floor(Math.random() * 16).toString(16)).join("")}`;
+}
+function createDefaultBlock(type) {
+  const id = makeId();
+  switch (type) {
+    case "heading":
+      return { id, type: "heading", as: "h1", text: "Heading" };
+    case "text":
+      return {
+        id,
+        type: "text",
+        text: "Start writing your email content here..."
+      };
+    case "button":
+      return {
+        id,
+        type: "button",
+        text: "Click Here",
+        href: "https://example.com",
+        variant: "primary"
+      };
+    case "image":
+      return {
+        id,
+        type: "image",
+        src: "https://placehold.co/600x200/e2e8f0/64748b?text=Image",
+        alt: "Image",
+        width: 600
+      };
+    case "divider":
+      return { id, type: "divider" };
+    case "spacer":
+      return { id, type: "spacer", height: 24 };
+    case "code":
+      return { id, type: "code", text: "123456" };
+    case "link":
+      return {
+        id,
+        type: "link",
+        text: "Click here",
+        href: "https://example.com"
+      };
+    case "columns":
+      return {
+        id,
+        type: "columns",
+        columns: [
+          { width: "50%", blocks: [] },
+          { width: "50%", blocks: [] }
+        ]
+      };
+  }
+}
+function interpolateVariables(text, variables) {
+  return text.replace(/\{\{(\w+)\}\}/g, (match, name) => {
+    return variables[name] ?? match;
+  });
+}
+function extractVariables(blocks) {
+  const vars = /* @__PURE__ */ new Set();
+  const regex = /\{\{(\w+)\}\}/g;
+  function scan(text) {
+    for (let m = regex.exec(text); m !== null; m = regex.exec(text)) {
+      if (m[1]) vars.add(m[1]);
+    }
+  }
+  function walk(blockList) {
+    for (const block of blockList) {
+      switch (block.type) {
+        case "heading":
+        case "text":
+        case "code":
+          scan(block.text);
+          break;
+        case "button":
+          scan(block.text);
+          scan(block.href);
+          break;
+        case "link":
+          scan(block.text);
+          scan(block.href);
+          break;
+        case "image":
+          scan(block.src);
+          break;
+        case "columns":
+          for (const col of block.columns) {
+            walk(col.blocks);
+          }
+          break;
+      }
+    }
+  }
+  walk(blocks);
+  return [...vars];
+}
+function getBuiltInTemplateBlocks(type) {
+  switch (type) {
+    case "verification":
+      return [
+        { id: makeId(), type: "heading", as: "h1", text: "Verify your email address" },
+        { id: makeId(), type: "text", text: "Hi {{userName}}," },
+        {
+          id: makeId(),
+          type: "text",
+          text: "Thanks for signing up! Please verify your email address by clicking the button below."
+        },
+        {
+          id: makeId(),
+          type: "button",
+          text: "Verify Email",
+          href: "{{verificationUrl}}",
+          variant: "primary"
+        },
+        { id: makeId(), type: "divider" },
+        {
+          id: makeId(),
+          type: "text",
+          text: "If the button doesn't work, copy and paste this URL into your browser:",
+          style: { fontSize: 12, color: "#94a3b8" }
+        },
+        {
+          id: makeId(),
+          type: "link",
+          text: "{{verificationUrl}}",
+          href: "{{verificationUrl}}",
+          style: { fontSize: 12 }
+        }
+      ];
+    case "password-reset":
+      return [
+        { id: makeId(), type: "heading", as: "h1", text: "Reset your password" },
+        { id: makeId(), type: "text", text: "Hi {{userName}}," },
+        {
+          id: makeId(),
+          type: "text",
+          text: "We received a request to reset your password. Click the button below to choose a new password."
+        },
+        {
+          id: makeId(),
+          type: "button",
+          text: "Reset Password",
+          href: "{{resetUrl}}",
+          variant: "primary"
+        },
+        { id: makeId(), type: "divider" },
+        {
+          id: makeId(),
+          type: "text",
+          text: "This link expires in 1 hour. If you didn't request a password reset, you can safely ignore this email.",
+          style: { fontSize: 12, color: "#94a3b8" }
+        }
+      ];
+    case "magic-link":
+      return [
+        { id: makeId(), type: "heading", as: "h1", text: "Sign in to your account" },
+        { id: makeId(), type: "text", text: "Hi there," },
+        {
+          id: makeId(),
+          type: "text",
+          text: "Click the button below to sign in to your account. This link expires in 10 minutes."
+        },
+        {
+          id: makeId(),
+          type: "button",
+          text: "Sign In",
+          href: "{{magicLinkUrl}}",
+          variant: "primary"
+        },
+        { id: makeId(), type: "divider" },
+        {
+          id: makeId(),
+          type: "text",
+          text: "If you didn't request this link, you can safely ignore this email.",
+          style: { fontSize: 12, color: "#94a3b8" }
+        }
+      ];
+    case "email-otp":
+      return [
+        { id: makeId(), type: "heading", as: "h1", text: "Your verification code" },
+        {
+          id: makeId(),
+          type: "text",
+          text: "Use the code below to verify your identity. It expires in 10 minutes."
+        },
+        { id: makeId(), type: "code", text: "{{otp}}" },
+        { id: makeId(), type: "divider" },
+        {
+          id: makeId(),
+          type: "text",
+          text: "If you didn't request this code, you can safely ignore this email. Never share this code with anyone.",
+          style: { fontSize: 12, color: "#94a3b8" }
+        }
+      ];
+    case "invitation":
+      return [
+        { id: makeId(), type: "heading", as: "h1", text: "You've been invited" },
+        {
+          id: makeId(),
+          type: "text",
+          text: "<strong>{{inviterName}}</strong> has invited you to join <strong>{{organizationName}}</strong>."
+        },
+        {
+          id: makeId(),
+          type: "button",
+          text: "Accept Invitation",
+          href: "{{acceptUrl}}",
+          variant: "primary"
+        },
+        { id: makeId(), type: "divider" },
+        {
+          id: makeId(),
+          type: "link",
+          text: "{{acceptUrl}}",
+          href: "{{acceptUrl}}",
+          style: { fontSize: 12 }
+        }
+      ];
+    case "welcome":
+      return [
+        { id: makeId(), type: "heading", as: "h1", text: "Welcome to {{appName}}" },
+        { id: makeId(), type: "text", text: "Hi {{userName}}," },
+        {
+          id: makeId(),
+          type: "text",
+          text: "Your account has been created successfully. You're all set to get started."
+        },
+        {
+          id: makeId(),
+          type: "button",
+          text: "Go to Dashboard",
+          href: "{{dashboardUrl}}",
+          variant: "primary"
+        },
+        { id: makeId(), type: "divider" },
+        {
+          id: makeId(),
+          type: "text",
+          text: "If you didn't create this account, please contact support.",
+          style: { fontSize: 12, color: "#94a3b8" }
+        }
+      ];
+  }
+}
+
+exports.AuthenticationError = AuthenticationError;
+exports.BLOCK_PALETTE = BLOCK_PALETTE;
+exports.BanataAuthError = BanataAuthError;
+exports.ConflictError = ConflictError;
+exports.ForbiddenError = ForbiddenError;
+exports.ID_PREFIXES = ID_PREFIXES;
+exports.InternalError = InternalError;
+exports.NotFoundError = NotFoundError;
+exports.RATE_LIMITS = RATE_LIMITS;
+exports.RateLimitError = RateLimitError;
+exports.SIZE_LIMITS = SIZE_LIMITS;
+exports.TOKEN_LIFETIMES = TOKEN_LIFETIMES;
+exports.ValidationError = ValidationError;
+exports.WEBHOOK_MAX_ATTEMPTS = WEBHOOK_MAX_ATTEMPTS;
+exports.WEBHOOK_MAX_CONSECUTIVE_FAILURES = WEBHOOK_MAX_CONSECUTIVE_FAILURES;
+exports.WEBHOOK_RETRY_DELAYS = WEBHOOK_RETRY_DELAYS;
+exports.createAuditEventSchema = createAuditEventSchema;
+exports.createDefaultBlock = createDefaultBlock;
+exports.createErrorFromStatus = createErrorFromStatus;
+exports.createOrganizationSchema = createOrganizationSchema;
+exports.createSsoConnectionSchema = createSsoConnectionSchema;
+exports.createUserSchema = createUserSchema;
+exports.createWebhookEndpointSchema = createWebhookEndpointSchema;
+exports.domainSchema = domainSchema;
+exports.emailSchema = emailSchema;
+exports.extractVariables = extractVariables;
+exports.generateId = generateId;
+exports.generateOtp = generateOtp;
+exports.generateRandomToken = generateRandomToken;
+exports.getBuiltInTemplateBlocks = getBuiltInTemplateBlocks;
+exports.getResourceType = getResourceType;
+exports.httpsUrlSchema = httpsUrlSchema;
+exports.interpolateVariables = interpolateVariables;
+exports.inviteMemberSchema = inviteMemberSchema;
+exports.listEnabledSocialProviderIds = listEnabledSocialProviderIds;
+exports.metadataSchema = metadataSchema;
+exports.nameSchema = nameSchema;
+exports.paginationSchema = paginationSchema;
+exports.passwordSchema = passwordSchema;
+exports.slugSchema = slugSchema;
+exports.ulid = ulid;
+exports.updateOrganizationSchema = updateOrganizationSchema;
+exports.updateUserSchema = updateUserSchema;
+exports.urlSchema = urlSchema;
+exports.validateId = validateId;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map