@umituz/web-firebase 1.0.4 → 2.0.1

package/dist/domain/index.js

@@ -0,0 +1,662 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/domain/index.ts
+var domain_exports = {};
+__export(domain_exports, {
+  AuthError: () => AuthError,
+  AuthErrorCode: () => AuthErrorCode,
+  Email: () => Email,
+  FileErrorCode: () => FileErrorCode,
+  FilePath: () => FilePath,
+  RepositoryError: () => RepositoryError,
+  RepositoryErrorCode: () => RepositoryErrorCode,
+  Timestamp: () => Timestamp,
+  USER_COLLECTIONS: () => USER_COLLECTIONS,
+  USER_SUBCOLLECTIONS: () => USER_SUBCOLLECTIONS,
+  UserId: () => UserId,
+  createAuthError: () => createAuthError,
+  createRepositoryError: () => createRepositoryError,
+  serverTimestamp: () => serverTimestamp
+});
+module.exports = __toCommonJS(domain_exports);
+
+// src/domain/entities/user.entity.ts
+var USER_COLLECTIONS = {
+  USERS: "users",
+  CONTENT: "content",
+  ANALYTICS: "analytics",
+  CONNECTED_ACCOUNTS: "connectedAccounts"
+};
+var USER_SUBCOLLECTIONS = {
+  CONTENT: "content",
+  ANALYTICS: "analytics",
+  SCHEDULED: "scheduled",
+  PUBLISHED: "published",
+  DRAFTS: "drafts"
+};
+
+// src/domain/entities/file.entity.ts
+var FileErrorCode = /* @__PURE__ */ ((FileErrorCode2) => {
+  FileErrorCode2["FILE_TOO_LARGE"] = "FILE_TOO_LARGE";
+  FileErrorCode2["INVALID_TYPE"] = "INVALID_TYPE";
+  FileErrorCode2["INVALID_EXTENSION"] = "INVALID_EXTENSION";
+  FileErrorCode2["UPLOAD_FAILED"] = "UPLOAD_FAILED";
+  FileErrorCode2["DOWNLOAD_FAILED"] = "DOWNLOAD_FAILED";
+  FileErrorCode2["DELETE_FAILED"] = "DELETE_FAILED";
+  FileErrorCode2["FILE_NOT_FOUND"] = "FILE_NOT_FOUND";
+  FileErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  FileErrorCode2["CANCELLED"] = "CANCELLED";
+  return FileErrorCode2;
+})(FileErrorCode || {});
+
+// src/domain/entities/timestamp.entity.ts
+var Timestamp = class _Timestamp {
+  constructor(seconds, nanoseconds) {
+    this.seconds = seconds;
+    this.nanoseconds = nanoseconds;
+  }
+  /**
+   * Create Timestamp from JavaScript Date
+   */
+  static fromDate(date) {
+    const milliseconds = date.getTime();
+    const seconds = Math.floor(milliseconds / 1e3);
+    const nanoseconds = milliseconds % 1e3 * 1e6;
+    return new _Timestamp(seconds, nanoseconds);
+  }
+  /**
+   * Create Timestamp from milliseconds
+   */
+  static fromMillis(milliseconds) {
+    const seconds = Math.floor(milliseconds / 1e3);
+    const nanoseconds = milliseconds % 1e3 * 1e6;
+    return new _Timestamp(seconds, nanoseconds);
+  }
+  /**
+   * Create Timestamp from Firestore Timestamp
+   */
+  static fromFirestoreTimestamp(timestamp) {
+    return new _Timestamp(timestamp.seconds, timestamp.nanoseconds);
+  }
+  /**
+   * Get current timestamp
+   */
+  static now() {
+    return _Timestamp.fromDate(/* @__PURE__ */ new Date());
+  }
+  /**
+   * Convert to JavaScript Date
+   */
+  toDate() {
+    return new Date(this.seconds * 1e3 + this.nanoseconds / 1e6);
+  }
+  /**
+   * Convert to milliseconds
+   */
+  toMillis() {
+    return this.seconds * 1e3 + this.nanoseconds / 1e6;
+  }
+  /**
+   * Convert to Firestore Timestamp
+   */
+  toFirestoreTimestamp() {
+    return {
+      seconds: this.seconds,
+      nanoseconds: this.nanoseconds
+    };
+  }
+  /**
+   * Convert to ISO string
+   */
+  toISOString() {
+    return this.toDate().toISOString();
+  }
+  /**
+   * Check if timestamp is in the past
+   */
+  isPast() {
+    return this.toMillis() < Date.now();
+  }
+  /**
+   * Check if timestamp is in the future
+   */
+  isFuture() {
+    return this.toMillis() > Date.now();
+  }
+  /**
+   * Get difference in milliseconds with another timestamp
+   */
+  diff(other) {
+    return this.toMillis() - other.toMillis();
+  }
+};
+var serverTimestamp = {
+  __type__: "serverTimestamp"
+};
+
+// src/domain/value-objects/email.vo.ts
+var Email = class _Email {
+  value;
+  validated;
+  constructor(email) {
+    this.value = email.trim().toLowerCase();
+    this.validated = this.isValid();
+    if (!this.validated) {
+      throw new Error(`Invalid email address: ${email}`);
+    }
+  }
+  /**
+   * Validate email format
+   */
+  isValid() {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(this.value);
+  }
+  /**
+   * Get email value
+   */
+  getValue() {
+    return this.value;
+  }
+  /**
+   * Get local part (before @)
+   */
+  getLocalPart() {
+    return this.value.split("@")[0];
+  }
+  /**
+   * Get domain part (after @)
+   */
+  getDomain() {
+    return this.value.split("@")[1] || "";
+  }
+  /**
+   * Check if email is from a specific domain
+   */
+  isFromDomain(domain) {
+    return this.getDomain() === domain.toLowerCase();
+  }
+  /**
+   * Check if email is from a corporate domain (not gmail, yahoo, etc.)
+   */
+  isCorporate() {
+    const freeDomains = [
+      "gmail.com",
+      "yahoo.com",
+      "hotmail.com",
+      "outlook.com",
+      "aol.com",
+      "icloud.com",
+      "protonmail.com"
+    ];
+    return !freeDomains.includes(this.getDomain());
+  }
+  /**
+   * Mask email for display (e.g., u***@gmail.com)
+   */
+  mask() {
+    const [local, domain] = this.value.split("@");
+    if (local.length <= 2) {
+      return `${local[0]}***@${domain}`;
+    }
+    return `${local[0]}${"*".repeat(local.length - 2)}${local[local.length - 1]}@${domain}`;
+  }
+  /**
+   * Convert to string
+   */
+  toString() {
+    return this.value;
+  }
+  /**
+   * Check equality with another email
+   */
+  equals(other) {
+    return this.value === other.value;
+  }
+  /**
+   * Create Email from string (returns null if invalid)
+   */
+  static create(email) {
+    try {
+      return new _Email(email);
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/domain/errors/repository.errors.ts
+var RepositoryError = class extends Error {
+  constructor(message, code, originalError) {
+    super(message);
+    this.code = code;
+    this.originalError = originalError;
+    this.name = "RepositoryError";
+  }
+};
+var RepositoryErrorCode = /* @__PURE__ */ ((RepositoryErrorCode2) => {
+  RepositoryErrorCode2["DOCUMENT_NOT_FOUND"] = "DOCUMENT_NOT_FOUND";
+  RepositoryErrorCode2["DOCUMENT_ALREADY_EXISTS"] = "DOCUMENT_ALREADY_EXISTS";
+  RepositoryErrorCode2["DOCUMENT_INVALID"] = "DOCUMENT_INVALID";
+  RepositoryErrorCode2["COLLECTION_NOT_FOUND"] = "COLLECTION_NOT_FOUND";
+  RepositoryErrorCode2["COLLECTION_INVALID"] = "COLLECTION_INVALID";
+  RepositoryErrorCode2["QUERY_INVALID"] = "QUERY_INVALID";
+  RepositoryErrorCode2["QUERY_FAILED"] = "QUERY_FAILED";
+  RepositoryErrorCode2["TRANSACTION_FAILED"] = "TRANSACTION_FAILED";
+  RepositoryErrorCode2["TRANSACTION_ABORTED"] = "TRANSACTION_ABORTED";
+  RepositoryErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  RepositoryErrorCode2["TIMEOUT"] = "TIMEOUT";
+  RepositoryErrorCode2["OFFLINE"] = "OFFLINE";
+  RepositoryErrorCode2["PERMISSION_DENIED"] = "PERMISSION_DENIED";
+  RepositoryErrorCode2["UNAUTHORIZED"] = "UNAUTHORIZED";
+  RepositoryErrorCode2["VALIDATION_FAILED"] = "VALIDATION_FAILED";
+  RepositoryErrorCode2["INVALID_DATA"] = "INVALID_DATA";
+  RepositoryErrorCode2["CONFLICT"] = "CONFLICT";
+  RepositoryErrorCode2["VERSION_MISMATCH"] = "VERSION_MISMATCH";
+  RepositoryErrorCode2["STORAGE_ERROR"] = "STORAGE_ERROR";
+  RepositoryErrorCode2["FILE_NOT_FOUND"] = "FILE_NOT_FOUND";
+  RepositoryErrorCode2["FILE_TOO_LARGE"] = "FILE_TOO_LARGE";
+  RepositoryErrorCode2["INVALID_FILE_TYPE"] = "INVALID_FILE_TYPE";
+  RepositoryErrorCode2["UNKNOWN"] = "UNKNOWN";
+  return RepositoryErrorCode2;
+})(RepositoryErrorCode || {});
+function createRepositoryError(code, message, originalError) {
+  const defaultMessage = getRepositoryErrorMessage(code);
+  return new RepositoryError(message || defaultMessage, code, originalError);
+}
+function getRepositoryErrorMessage(code) {
+  switch (code) {
+    case "DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */:
+      return "Document not found";
+    case "DOCUMENT_ALREADY_EXISTS" /* DOCUMENT_ALREADY_EXISTS */:
+      return "Document already exists";
+    case "DOCUMENT_INVALID" /* DOCUMENT_INVALID */:
+      return "Document is invalid";
+    case "COLLECTION_NOT_FOUND" /* COLLECTION_NOT_FOUND */:
+      return "Collection not found";
+    case "COLLECTION_INVALID" /* COLLECTION_INVALID */:
+      return "Collection is invalid";
+    case "QUERY_INVALID" /* QUERY_INVALID */:
+      return "Query is invalid";
+    case "QUERY_FAILED" /* QUERY_FAILED */:
+      return "Query failed";
+    case "TRANSACTION_FAILED" /* TRANSACTION_FAILED */:
+      return "Transaction failed";
+    case "TRANSACTION_ABORTED" /* TRANSACTION_ABORTED */:
+      return "Transaction aborted";
+    case "NETWORK_ERROR" /* NETWORK_ERROR */:
+      return "Network error";
+    case "TIMEOUT" /* TIMEOUT */:
+      return "Request timeout";
+    case "OFFLINE" /* OFFLINE */:
+      return "Client is offline";
+    case "PERMISSION_DENIED" /* PERMISSION_DENIED */:
+      return "Permission denied";
+    case "UNAUTHORIZED" /* UNAUTHORIZED */:
+      return "Unauthorized";
+    case "VALIDATION_FAILED" /* VALIDATION_FAILED */:
+      return "Validation failed";
+    case "INVALID_DATA" /* INVALID_DATA */:
+      return "Invalid data";
+    case "CONFLICT" /* CONFLICT */:
+      return "Conflict occurred";
+    case "VERSION_MISMATCH" /* VERSION_MISMATCH */:
+      return "Version mismatch";
+    case "STORAGE_ERROR" /* STORAGE_ERROR */:
+      return "Storage error";
+    case "FILE_NOT_FOUND" /* FILE_NOT_FOUND */:
+      return "File not found";
+    case "FILE_TOO_LARGE" /* FILE_TOO_LARGE */:
+      return "File is too large";
+    case "INVALID_FILE_TYPE" /* INVALID_FILE_TYPE */:
+      return "Invalid file type";
+    case "UNKNOWN" /* UNKNOWN */:
+    default:
+      return "An unknown error occurred";
+  }
+}
+
+// src/domain/value-objects/user-id.vo.ts
+var UserId = class _UserId {
+  value;
+  constructor(id) {
+    this.value = id;
+    this.validate();
+  }
+  /**
+   * Validate user ID
+   */
+  validate() {
+    if (!this.value) {
+      throw createRepositoryError("INVALID_DATA" /* INVALID_DATA */, "User ID cannot be empty");
+    }
+    if (this.value.length < 20) {
+      throw createRepositoryError(
+        "INVALID_DATA" /* INVALID_DATA */,
+        "User ID is too short (must be at least 20 characters)"
+      );
+    }
+    const validPattern = /^[a-zA-Z0-9_-]+$/;
+    if (!validPattern.test(this.value)) {
+      throw createRepositoryError(
+        "INVALID_DATA" /* INVALID_DATA */,
+        "User ID contains invalid characters"
+      );
+    }
+  }
+  /**
+   * Get user ID value
+   */
+  getValue() {
+    return this.value;
+  }
+  /**
+   * Check if this is a temporary ID (not yet persisted)
+   */
+  isTemporary() {
+    return this.value.startsWith("temp_");
+  }
+  /**
+   * Convert to string
+   */
+  toString() {
+    return this.value;
+  }
+  /**
+   * Check equality with another user ID
+   */
+  equals(other) {
+    return this.value === other.value;
+  }
+  /**
+   * Generate a temporary user ID
+   */
+  static generateTemp() {
+    return new _UserId(`temp_${Date.now()}_${Math.random().toString(36).substring(7)}`);
+  }
+  /**
+   * Create UserId from string (returns null if invalid)
+   */
+  static create(id) {
+    try {
+      return new _UserId(id);
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/domain/value-objects/file-path.vo.ts
+var FilePath = class _FilePath {
+  value;
+  parts;
+  constructor(path) {
+    this.value = path.trim();
+    this.parts = this.value.split("/").filter((p) => p.length > 0);
+    this.validate();
+  }
+  /**
+   * Validate file path
+   */
+  validate() {
+    if (!this.value) {
+      throw createRepositoryError("INVALID_DATA" /* INVALID_DATA */, "File path cannot be empty");
+    }
+    if (this.value.startsWith("/") || this.value.endsWith("/")) {
+      throw createRepositoryError(
+        "INVALID_DATA" /* INVALID_DATA */,
+        "File path should not start or end with /"
+      );
+    }
+    if (this.value.includes("//")) {
+      throw createRepositoryError("INVALID_DATA" /* INVALID_DATA */, "File path should not contain //");
+    }
+    if (this.parts.length === 0) {
+      throw createRepositoryError("INVALID_DATA" /* INVALID_DATA */, "File path must have at least one segment");
+    }
+    for (const part of this.parts) {
+      if (/[<>:"|?*]/.test(part)) {
+        throw createRepositoryError(
+          "INVALID_DATA" /* INVALID_DATA */,
+          `Invalid characters in path segment: ${part}`
+        );
+      }
+      if (part === "." || part === "..") {
+        throw createRepositoryError(
+          "INVALID_DATA" /* INVALID_DATA */,
+          `Invalid path segment: ${part}`
+        );
+      }
+    }
+  }
+  /**
+   * Get file path value
+   */
+  getValue() {
+    return this.value;
+  }
+  /**
+   * Get path parts
+   */
+  getParts() {
+    return [...this.parts];
+  }
+  /**
+   * Get filename (last part of path)
+   */
+  getFileName() {
+    return this.parts[this.parts.length - 1] || "";
+  }
+  /**
+   * Get directory path (all parts except last)
+   */
+  getDirectory() {
+    return this.parts.slice(0, -1).join("/");
+  }
+  /**
+   * Get file extension
+   */
+  getExtension() {
+    const fileName = this.getFileName();
+    const lastDot = fileName.lastIndexOf(".");
+    return lastDot > 0 ? fileName.substring(lastDot + 1) : "";
+  }
+  /**
+   * Get file name without extension
+   */
+  getFileNameWithoutExtension() {
+    const fileName = this.getFileName();
+    const lastDot = fileName.lastIndexOf(".");
+    return lastDot > 0 ? fileName.substring(0, lastDot) : fileName;
+  }
+  /**
+   * Check if path is in a specific directory
+   */
+  isInDirectory(directory) {
+    return this.value.startsWith(directory + "/");
+  }
+  /**
+   * Check if file has a specific extension
+   */
+  hasExtension(extension) {
+    return this.getExtension().toLowerCase() === extension.toLowerCase();
+  }
+  /**
+   * Create a new path by appending segments
+   */
+  append(...segments) {
+    return new _FilePath([...this.parts, ...segments].join("/"));
+  }
+  /**
+   * Create a new path in a parent directory
+   */
+  withParent(parent) {
+    return new _FilePath([parent, ...this.parts].join("/"));
+  }
+  /**
+   * Create a new path with a different filename
+   */
+  withFileName(fileName) {
+    const dir = this.getDirectory();
+    return dir ? new _FilePath(`${dir}/${fileName}`) : new _FilePath(fileName);
+  }
+  /**
+   * Convert to string
+   */
+  toString() {
+    return this.value;
+  }
+  /**
+   * Check equality with another file path
+   */
+  equals(other) {
+    return this.value === other.value;
+  }
+  /**
+   * Create user path (users/{userId}/...)
+   */
+  static userPath(userId, ...segments) {
+    return new _FilePath(["users", userId, ...segments].join("/"));
+  }
+  /**
+   * Create public path (public/...)
+   */
+  static publicPath(...segments) {
+    return new _FilePath(["public", ...segments].join("/"));
+  }
+  /**
+   * Create FilePath from string (returns null if invalid)
+   */
+  static create(path) {
+    try {
+      return new _FilePath(path);
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/domain/errors/auth.errors.ts
+var AuthError = class extends Error {
+  constructor(message, code, originalError) {
+    super(message);
+    this.code = code;
+    this.originalError = originalError;
+    this.name = "AuthError";
+  }
+};
+var AuthErrorCode = /* @__PURE__ */ ((AuthErrorCode2) => {
+  AuthErrorCode2["USER_NOT_FOUND"] = "USER_NOT_FOUND";
+  AuthErrorCode2["USER_ALREADY_EXISTS"] = "USER_ALREADY_EXISTS";
+  AuthErrorCode2["INVALID_CREDENTIALS"] = "INVALID_CREDENTIALS";
+  AuthErrorCode2["WEAK_PASSWORD"] = "WEAK_PASSWORD";
+  AuthErrorCode2["EMAIL_NOT_VERIFIED"] = "EMAIL_NOT_VERIFIED";
+  AuthErrorCode2["SESSION_EXPIRED"] = "SESSION_EXPIRED";
+  AuthErrorCode2["UNAUTHENTICATED"] = "UNAUTHENTICATED";
+  AuthErrorCode2["TOO_MANY_REQUESTS"] = "TOO_MANY_REQUESTS";
+  AuthErrorCode2["OAUTH_ERROR"] = "OAUTH_ERROR";
+  AuthErrorCode2["OAUTH_CANCELLED"] = "OAUTH_CANCELLED";
+  AuthErrorCode2["OAUTH_ACCOUNT_EXISTS"] = "OAUTH_ACCOUNT_EXISTS";
+  AuthErrorCode2["SIGN_IN_FAILED"] = "SIGN_IN_FAILED";
+  AuthErrorCode2["SIGN_UP_FAILED"] = "SIGN_UP_FAILED";
+  AuthErrorCode2["SIGN_OUT_FAILED"] = "SIGN_OUT_FAILED";
+  AuthErrorCode2["PASSWORD_RESET_FAILED"] = "PASSWORD_RESET_FAILED";
+  AuthErrorCode2["EMAIL_VERIFICATION_FAILED"] = "EMAIL_VERIFICATION_FAILED";
+  AuthErrorCode2["PROFILE_UPDATE_FAILED"] = "PROFILE_UPDATE_FAILED";
+  AuthErrorCode2["EMAIL_UPDATE_FAILED"] = "EMAIL_UPDATE_FAILED";
+  AuthErrorCode2["PASSWORD_UPDATE_FAILED"] = "PASSWORD_UPDATE_FAILED";
+  AuthErrorCode2["ACCOUNT_DELETE_FAILED"] = "ACCOUNT_DELETE_FAILED";
+  AuthErrorCode2["REAUTHENTICATION_REQUIRED"] = "REAUTHENTICATION_REQUIRED";
+  AuthErrorCode2["REAUTHENTICATION_FAILED"] = "REAUTHENTICATION_FAILED";
+  AuthErrorCode2["UNKNOWN"] = "UNKNOWN";
+  return AuthErrorCode2;
+})(AuthErrorCode || {});
+function createAuthError(code, message, originalError) {
+  const defaultMessage = getAuthErrorMessage(code);
+  return new AuthError(message || defaultMessage, code, originalError);
+}
+function getAuthErrorMessage(code) {
+  switch (code) {
+    case "USER_NOT_FOUND" /* USER_NOT_FOUND */:
+      return "User not found";
+    case "USER_ALREADY_EXISTS" /* USER_ALREADY_EXISTS */:
+      return "User already exists";
+    case "INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */:
+      return "Invalid credentials";
+    case "WEAK_PASSWORD" /* WEAK_PASSWORD */:
+      return "Password is too weak";
+    case "EMAIL_NOT_VERIFIED" /* EMAIL_NOT_VERIFIED */:
+      return "Email not verified";
+    case "SESSION_EXPIRED" /* SESSION_EXPIRED */:
+      return "Session expired";
+    case "UNAUTHENTICATED" /* UNAUTHENTICATED */:
+      return "User not authenticated";
+    case "TOO_MANY_REQUESTS" /* TOO_MANY_REQUESTS */:
+      return "Too many requests";
+    case "OAUTH_ERROR" /* OAUTH_ERROR */:
+      return "OAuth error occurred";
+    case "OAUTH_CANCELLED" /* OAUTH_CANCELLED */:
+      return "OAuth cancelled by user";
+    case "OAUTH_ACCOUNT_EXISTS" /* OAUTH_ACCOUNT_EXISTS */:
+      return "Account already exists with this provider";
+    case "SIGN_IN_FAILED" /* SIGN_IN_FAILED */:
+      return "Sign in failed";
+    case "SIGN_UP_FAILED" /* SIGN_UP_FAILED */:
+      return "Sign up failed";
+    case "SIGN_OUT_FAILED" /* SIGN_OUT_FAILED */:
+      return "Sign out failed";
+    case "PASSWORD_RESET_FAILED" /* PASSWORD_RESET_FAILED */:
+      return "Password reset failed";
+    case "EMAIL_VERIFICATION_FAILED" /* EMAIL_VERIFICATION_FAILED */:
+      return "Email verification failed";
+    case "PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */:
+      return "Profile update failed";
+    case "EMAIL_UPDATE_FAILED" /* EMAIL_UPDATE_FAILED */:
+      return "Email update failed";
+    case "PASSWORD_UPDATE_FAILED" /* PASSWORD_UPDATE_FAILED */:
+      return "Password update failed";
+    case "ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */:
+      return "Account deletion failed";
+    case "REAUTHENTICATION_REQUIRED" /* REAUTHENTICATION_REQUIRED */:
+      return "Reauthentication required";
+    case "REAUTHENTICATION_FAILED" /* REAUTHENTICATION_FAILED */:
+      return "Reauthentication failed";
+    case "UNKNOWN" /* UNKNOWN */:
+    default:
+      return "An unknown error occurred";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthError,
+  AuthErrorCode,
+  Email,
+  FileErrorCode,
+  FilePath,
+  RepositoryError,
+  RepositoryErrorCode,
+  Timestamp,
+  USER_COLLECTIONS,
+  USER_SUBCOLLECTIONS,
+  UserId,
+  createAuthError,
+  createRepositoryError,
+  serverTimestamp
+});

package/dist/domain/index.mjs

@@ -0,0 +1,36 @@
+import {
+  Email,
+  FileErrorCode,
+  FilePath,
+  Timestamp,
+  USER_COLLECTIONS,
+  USER_SUBCOLLECTIONS,
+  UserId,
+  serverTimestamp
+} from "../chunk-I6WGBPFB.mjs";
+import {
+  RepositoryError,
+  RepositoryErrorCode,
+  createRepositoryError
+} from "../chunk-4FP2ELQ5.mjs";
+import {
+  AuthError,
+  AuthErrorCode,
+  createAuthError
+} from "../chunk-RZ4QR6TB.mjs";
+export {
+  AuthError,
+  AuthErrorCode,
+  Email,
+  FileErrorCode,
+  FilePath,
+  RepositoryError,
+  RepositoryErrorCode,
+  Timestamp,
+  USER_COLLECTIONS,
+  USER_SUBCOLLECTIONS,
+  UserId,
+  createAuthError,
+  createRepositoryError,
+  serverTimestamp
+};