@umituz/web-firebase 1.0.5 → 2.0.1

package/dist/index.js

@@ -20,97 +20,1700 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  FirestoreRepository: () => FirestoreRepository,
+  AuthAdapter: () => AuthAdapter,
+  AuthError: () => AuthError,
+  AuthErrorCode: () => AuthErrorCode,
+  DeleteAccountUseCase: () => DeleteAccountUseCase,
+  Email: () => Email,
+  FileErrorCode: () => FileErrorCode,
+  FilePath: () => FilePath,
+  FirestoreAdapter: () => FirestoreAdapter,
+  RepositoryError: () => RepositoryError,
+  RepositoryErrorCode: () => RepositoryErrorCode,
+  ResetPasswordUseCase: () => ResetPasswordUseCase,
+  SignInUseCase: () => SignInUseCase,
+  SignInWithGoogleUseCase: () => SignInWithGoogleUseCase,
+  SignOutUseCase: () => SignOutUseCase,
+  SignUpUseCase: () => SignUpUseCase,
+  StorageAdapter: () => StorageAdapter,
+  Timestamp: () => Timestamp,
+  USER_COLLECTIONS: () => USER_COLLECTIONS,
+  USER_SUBCOLLECTIONS: () => USER_SUBCOLLECTIONS,
+  UpdateProfileUseCase: () => UpdateProfileUseCase,
+  UserId: () => UserId,
+  analytics: () => analytics,
+  app: () => app,
+  auth: () => auth,
+  createAuthError: () => createAuthError,
+  createRepositoryError: () => createRepositoryError,
+  db: () => db,
   deleteFile: () => deleteFile,
+  functions: () => functions,
+  getFirebaseAnalytics: () => getFirebaseAnalytics,
+  getFirebaseApp: () => getFirebaseApp,
+  getFirebaseAuth: () => getFirebaseAuth,
+  getFirebaseDB: () => getFirebaseDB,
+  getFirebaseFunctions: () => getFirebaseFunctions,
+  getFirebaseInstances: () => getFirebaseInstances,
+  getFirebaseStorage: () => getFirebaseStorage,
   initializeFirebase: () => initializeFirebase,
+  serverTimestamp: () => serverTimestamp,
+  storage: () => storage,
   uploadBase64: () => uploadBase64,
   uploadFile: () => uploadFile,
   useFirebaseAuth: () => useFirebaseAuth
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/infrastructure/services/firebase.service.ts
+// 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";
+  }
+}
+
+// src/application/use-cases/auth/sign-in.use-case.ts
+var SignInUseCase = class {
+  constructor(authRepository) {
+    this.authRepository = authRepository;
+  }
+  /**
+   * Execute sign in use case
+   */
+  async execute(dto) {
+    try {
+      this.validateDTO(dto);
+      const result = await this.authRepository.signIn(dto.email, dto.password);
+      return result;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+  /**
+   * Validate DTO
+   */
+  validateDTO(dto) {
+    if (!dto.email) {
+      throw createAuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, "Email is required");
+    }
+    if (!dto.password) {
+      throw createAuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, "Password is required");
+    }
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(dto.email)) {
+      throw createAuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, "Invalid email format");
+    }
+  }
+  /**
+   * Handle errors
+   */
+  handleError(error) {
+    if (error instanceof Error) {
+      const message = error.message.toLowerCase();
+      if (message.includes("user-not-found") || message.includes("invalid-email")) {
+        return createAuthError("USER_NOT_FOUND" /* USER_NOT_FOUND */, "User not found", error);
+      }
+      if (message.includes("wrong-password") || message.includes("invalid-credential")) {
+        return createAuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, "Invalid credentials", error);
+      }
+      if (message.includes("too-many-requests")) {
+        return createAuthError("TOO_MANY_REQUESTS" /* TOO_MANY_REQUESTS */, "Too many attempts", error);
+      }
+      if (message.includes("user-disabled")) {
+        return createAuthError("USER_NOT_FOUND" /* USER_NOT_FOUND */, "Account disabled", error);
+      }
+    }
+    return createAuthError("SIGN_IN_FAILED" /* SIGN_IN_FAILED */, "Sign in failed", error);
+  }
+};
+
+// src/application/use-cases/auth/sign-up.use-case.ts
+var SignUpUseCase = class {
+  constructor(authRepository, userRepository) {
+    this.authRepository = authRepository;
+    this.userRepository = userRepository;
+  }
+  /**
+   * Execute sign up use case
+   */
+  async execute(dto) {
+    try {
+      this.validateDTO(dto);
+      const existingUser = await this.userRepository.getUserByEmail(dto.email);
+      if (existingUser) {
+        throw createAuthError("USER_ALREADY_EXISTS" /* USER_ALREADY_EXISTS */, "User already exists");
+      }
+      const result = await this.authRepository.signUp(dto.email, dto.password, dto.displayName);
+      return {
+        ...result,
+        userId: result.user.uid,
+        emailVerified: result.user.emailVerified
+      };
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+  /**
+   * Validate DTO
+   */
+  validateDTO(dto) {
+    if (!dto.email) {
+      throw createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Email is required");
+    }
+    if (!dto.password) {
+      throw createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Password is required");
+    }
+    if (!dto.displayName || dto.displayName.trim().length === 0) {
+      throw createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Display name is required");
+    }
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(dto.email)) {
+      throw createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Invalid email format");
+    }
+    if (dto.password.length < 6) {
+      throw createAuthError("WEAK_PASSWORD" /* WEAK_PASSWORD */, "Password must be at least 6 characters");
+    }
+  }
+  /**
+   * Handle errors
+   */
+  handleError(error) {
+    if (error instanceof Error && "code" in error) {
+      const code = error.code;
+      if (code === "auth/email-already-in-use") {
+        return createAuthError("USER_ALREADY_EXISTS" /* USER_ALREADY_EXISTS */, "Email already in use", error);
+      }
+      if (code === "auth/invalid-email") {
+        return createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Invalid email", error);
+      }
+      if (code === "auth/weak-password") {
+        return createAuthError("WEAK_PASSWORD" /* WEAK_PASSWORD */, "Password is too weak", error);
+      }
+      if (code === "auth/operation-not-allowed") {
+        return createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Email/password accounts not enabled", error);
+      }
+    }
+    return createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Sign up failed", error);
+  }
+};
+
+// src/application/use-cases/auth/sign-in-with-google.use-case.ts
+var SignInWithGoogleUseCase = class {
+  constructor(authRepository, userRepository) {
+    this.authRepository = authRepository;
+    this.userRepository = userRepository;
+  }
+  /**
+   * Execute Google sign in use case
+   */
+  async execute() {
+    try {
+      const result = await this.authRepository.signInWithGoogle();
+      const existingUser = await this.userRepository.getUser(result.user.uid);
+      if (!existingUser) {
+        const createUserDTO = {
+          id: result.user.uid,
+          email: result.user.email || "",
+          displayName: result.user.displayName || "",
+          photoURL: result.user.photoURL || void 0,
+          phoneNumber: result.user.phoneNumber || void 0,
+          emailVerified: result.user.emailVerified
+        };
+        await this.authRepository.createUserDocument(result.user.uid, createUserDTO);
+      }
+      return result;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+  /**
+   * Handle errors
+   */
+  handleError(error) {
+    if (error instanceof Error && "code" in error) {
+      const code = error.code;
+      if (code === "auth/popup-closed-by-user") {
+        return createAuthError("OAUTH_CANCELLED" /* OAUTH_CANCELLED */, "Google sign in cancelled", error);
+      }
+      if (code === "auth/popup-blocked") {
+        return createAuthError("OAUTH_ERROR" /* OAUTH_ERROR */, "Popup blocked by browser", error);
+      }
+      if (code === "auth/account-exists-with-different-credential") {
+        return createAuthError(
+          "OAUTH_ACCOUNT_EXISTS" /* OAUTH_ACCOUNT_EXISTS */,
+          "Account already exists with different credential",
+          error
+        );
+      }
+      if (code === "auth/auth-domain-policy-required") {
+        return createAuthError("OAUTH_ERROR" /* OAUTH_ERROR */, "Auth domain not configured", error);
+      }
+      if (code === "auth/unauthorized-domain") {
+        return createAuthError("OAUTH_ERROR" /* OAUTH_ERROR */, "Unauthorized domain", error);
+      }
+      if (code === "auth/cancelled-popup-request") {
+        return createAuthError("OAUTH_CANCELLED" /* OAUTH_CANCELLED */, "Sign in cancelled", error);
+      }
+    }
+    return createAuthError("OAUTH_ERROR" /* OAUTH_ERROR */, "Google sign in failed", error);
+  }
+};
+
+// src/application/use-cases/auth/reset-password.use-case.ts
+var ResetPasswordUseCase = class {
+  constructor(authRepository) {
+    this.authRepository = authRepository;
+  }
+  /**
+   * Execute password reset use case
+   */
+  async execute(dto) {
+    try {
+      this.validateDTO(dto);
+      await this.authRepository.sendPasswordReset(dto.email);
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+  /**
+   * Validate DTO
+   */
+  validateDTO(dto) {
+    if (!dto.email) {
+      throw createAuthError("PASSWORD_RESET_FAILED" /* PASSWORD_RESET_FAILED */, "Email is required");
+    }
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(dto.email)) {
+      throw createAuthError("PASSWORD_RESET_FAILED" /* PASSWORD_RESET_FAILED */, "Invalid email format");
+    }
+  }
+  /**
+   * Handle errors
+   */
+  handleError(error) {
+    if (error instanceof Error && "code" in error) {
+      const code = error.code;
+      if (code === "auth/invalid-email") {
+        return createAuthError("PASSWORD_RESET_FAILED" /* PASSWORD_RESET_FAILED */, "Invalid email", error);
+      }
+      if (code === "auth/user-not-found") {
+        return createAuthError("PASSWORD_RESET_FAILED" /* PASSWORD_RESET_FAILED */, "Password reset email sent if account exists");
+      }
+      if (code === "auth/too-many-requests") {
+        return createAuthError("TOO_MANY_REQUESTS" /* TOO_MANY_REQUESTS */, "Too many requests", error);
+      }
+    }
+    return createAuthError("PASSWORD_RESET_FAILED" /* PASSWORD_RESET_FAILED */, "Password reset failed", error);
+  }
+};
+
+// src/application/use-cases/auth/sign-out.use-case.ts
+var SignOutUseCase = class {
+  constructor(authRepository) {
+    this.authRepository = authRepository;
+  }
+  /**
+   * Execute sign out use case
+   */
+  async execute() {
+    try {
+      await this.authRepository.signOut();
+    } catch (error) {
+      throw createAuthError("SIGN_OUT_FAILED" /* SIGN_OUT_FAILED */, "Sign out failed", error);
+    }
+  }
+};
+
+// src/application/use-cases/user/update-profile.use-case.ts
+var UpdateProfileUseCase = class {
+  constructor(authRepository) {
+    this.authRepository = authRepository;
+  }
+  /**
+   * Execute profile update use case
+   */
+  async execute(dto) {
+    try {
+      this.validateDTO(dto);
+      const currentUser = this.authRepository.getCurrentUser();
+      if (!currentUser) {
+        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
+      }
+      await this.authRepository.updateProfile(dto);
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+  /**
+   * Validate DTO
+   */
+  validateDTO(dto) {
+    if (!dto.displayName && !dto.photoURL) {
+      throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "At least one field must be provided");
+    }
+    if (dto.displayName !== void 0) {
+      if (typeof dto.displayName !== "string") {
+        throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Display name must be a string");
+      }
+      if (dto.displayName.trim().length === 0) {
+        throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Display name cannot be empty");
+      }
+      if (dto.displayName.length > 100) {
+        throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Display name too long (max 100 characters)");
+      }
+    }
+    if (dto.photoURL !== void 0 && dto.photoURL !== null) {
+      if (typeof dto.photoURL !== "string") {
+        throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Photo URL must be a string");
+      }
+      if (dto.photoURL && !this.isValidURL(dto.photoURL)) {
+        throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Invalid photo URL");
+      }
+    }
+  }
+  /**
+   * Validate URL format
+   */
+  isValidURL(url) {
+    try {
+      new URL(url);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Handle errors
+   */
+  handleError(error) {
+    if (error instanceof Error && "code" in error) {
+      const code = error.code;
+      if (code === "auth/requires-recent-login") {
+        return createAuthError("REAUTHENTICATION_REQUIRED" /* REAUTHENTICATION_REQUIRED */, "Please reauthenticate first", error);
+      }
+      if (code === "auth/invalid-photo-url") {
+        return createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Invalid photo URL", error);
+      }
+    }
+    return createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Profile update failed", error);
+  }
+};
+
+// src/application/use-cases/user/delete-account.use-case.ts
+var DeleteAccountUseCase = class {
+  constructor(authRepository) {
+    this.authRepository = authRepository;
+  }
+  /**
+   * Execute account deletion use case
+   */
+  async execute(dto) {
+    try {
+      this.validateDTO(dto);
+      const currentUser = this.authRepository.getCurrentUser();
+      if (!currentUser) {
+        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
+      }
+      if (!currentUser.email) {
+        throw createAuthError("ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */, "User email not available");
+      }
+      await this.authRepository.deleteAccount(dto.password);
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+  /**
+   * Validate DTO
+   */
+  validateDTO(dto) {
+    if (!dto.password) {
+      throw createAuthError("ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */, "Password is required");
+    }
+    if (dto.password.length < 1) {
+      throw createAuthError("ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */, "Password cannot be empty");
+    }
+  }
+  /**
+   * Handle errors
+   */
+  handleError(error) {
+    if (error instanceof Error && "code" in error) {
+      const code = error.code;
+      if (code === "auth/requires-recent-login") {
+        return createAuthError("REAUTHENTICATION_REQUIRED" /* REAUTHENTICATION_REQUIRED */, "Please reauthenticate first", error);
+      }
+      if (code === "auth/wrong-password") {
+        return createAuthError("REAUTHENTICATION_FAILED" /* REAUTHENTICATION_FAILED */, "Invalid password", error);
+      }
+      if (code === "auth/too-many-requests") {
+        return createAuthError("TOO_MANY_REQUESTS" /* TOO_MANY_REQUESTS */, "Too many requests", error);
+      }
+      if (code === "auth/user-not-found") {
+        return createAuthError("ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */, "User not found", error);
+      }
+    }
+    return createAuthError("ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */, "Account deletion failed", error);
+  }
+};
+
+// src/infrastructure/firebase/client.ts
 var import_app = require("firebase/app");
-var import_auth = require("firebase/auth");
+var import_auth8 = require("firebase/auth");
 var import_firestore = require("firebase/firestore");
 var import_storage = require("firebase/storage");
+var import_analytics = require("firebase/analytics");
 var import_functions = require("firebase/functions");
-function initializeFirebase(config, appName) {
-  const existing = (0, import_app.getApps)().find((a) => a.name === (appName ?? "[DEFAULT]"));
-  const app = existing ?? (0, import_app.initializeApp)(config, appName);
+var firebaseConfig = {
+  apiKey: process.env.VITE_FIREBASE_API_KEY,
+  authDomain: process.env.VITE_FIREBASE_AUTH_DOMAIN,
+  projectId: process.env.VITE_FIREBASE_PROJECT_ID,
+  storageBucket: process.env.VITE_FIREBASE_STORAGE_BUCKET,
+  messagingSenderId: process.env.VITE_FIREBASE_MESSAGING_SENDER_ID,
+  appId: process.env.VITE_FIREBASE_APP_ID,
+  measurementId: process.env.VITE_FIREBASE_MEASUREMENT_ID
+};
+var app;
+var auth;
+var db;
+var storage;
+var functions;
+var analytics = null;
+function initializeFirebase() {
+  if (!(0, import_app.getApps)().length) {
+    app = (0, import_app.initializeApp)(firebaseConfig);
+  } else {
+    app = (0, import_app.getApps)()[0];
+  }
+  return app;
+}
+function getFirebaseApp() {
+  return app || initializeFirebase();
+}
+function getFirebaseAuth() {
+  if (!auth) {
+    const firebaseApp = getFirebaseApp();
+    if (typeof window !== "undefined") {
+      try {
+        auth = (0, import_auth8.getAuth)(firebaseApp);
+      } catch (e) {
+        console.warn("getAuth failed, trying initializeAuth...", e);
+        auth = (0, import_auth8.initializeAuth)(firebaseApp, {
+          persistence: import_auth8.browserLocalPersistence
+        });
+      }
+    } else {
+      auth = (0, import_auth8.getAuth)(firebaseApp);
+    }
+  }
+  return auth;
+}
+function getFirebaseDB() {
+  if (!db) {
+    db = (0, import_firestore.getFirestore)(getFirebaseApp());
+  }
+  return db;
+}
+function getFirebaseStorage() {
+  if (!storage) {
+    storage = (0, import_storage.getStorage)(getFirebaseApp());
+  }
+  return storage;
+}
+function getFirebaseFunctions() {
+  if (!functions) {
+    functions = (0, import_functions.getFunctions)(getFirebaseApp());
+  }
+  return functions;
+}
+function getFirebaseAnalytics() {
+  if (!analytics && typeof window !== "undefined") {
+    analytics = (0, import_analytics.getAnalytics)(getFirebaseApp());
+  }
+  return analytics;
+}
+function getFirebaseInstances() {
   return {
-    app,
-    auth: (0, import_auth.getAuth)(app),
-    db: (0, import_firestore.getFirestore)(app),
-    storage: (0, import_storage.getStorage)(app),
-    functions: (0, import_functions.getFunctions)(app)
+    app: getFirebaseApp(),
+    auth: getFirebaseAuth(),
+    db: getFirebaseDB(),
+    storage: getFirebaseStorage(),
+    functions: getFirebaseFunctions(),
+    analytics: getFirebaseAnalytics()
   };
 }
 
-// src/infrastructure/services/firestore.repository.ts
+// src/infrastructure/firebase/auth.adapter.ts
+var import_auth9 = require("firebase/auth");
+var import_auth10 = require("firebase/auth");
+var AuthAdapter = class {
+  get auth() {
+    return getFirebaseAuth();
+  }
+  // Authentication Methods
+  async signIn(email, password) {
+    try {
+      return await (0, import_auth9.signInWithEmailAndPassword)(this.auth, email, password);
+    } catch (error) {
+      throw this.handleAuthError(error);
+    }
+  }
+  async signUp(email, password, displayName) {
+    try {
+      const result = await (0, import_auth9.createUserWithEmailAndPassword)(this.auth, email, password);
+      await (0, import_auth9.updateProfile)(result.user, { displayName });
+      await (0, import_auth9.sendEmailVerification)(result.user);
+      return result;
+    } catch (error) {
+      throw this.handleAuthError(error);
+    }
+  }
+  async signInWithGoogle() {
+    try {
+      const provider = new import_auth10.GoogleAuthProvider();
+      provider.addScope("profile");
+      provider.addScope("email");
+      return await (0, import_auth9.signInWithPopup)(this.auth, provider);
+    } catch (error) {
+      throw this.handleAuthError(error);
+    }
+  }
+  async signOut() {
+    try {
+      await (0, import_auth9.signOut)(this.auth);
+    } catch (error) {
+      throw createAuthError("SIGN_OUT_FAILED" /* SIGN_OUT_FAILED */, "Sign out failed", error);
+    }
+  }
+  async sendPasswordReset(email) {
+    try {
+      await (0, import_auth9.sendPasswordResetEmail)(this.auth, email);
+    } catch (error) {
+      throw this.handleAuthError(error);
+    }
+  }
+  async resendEmailVerification() {
+    try {
+      const user = this.auth.currentUser;
+      if (!user) {
+        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
+      }
+      await (0, import_auth9.sendEmailVerification)(user);
+    } catch (error) {
+      throw createAuthError("EMAIL_VERIFICATION_FAILED" /* EMAIL_VERIFICATION_FAILED */, "Failed to resend verification", error);
+    }
+  }
+  // Profile Management
+  async updateProfile(updates) {
+    try {
+      const user = this.auth.currentUser;
+      if (!user) {
+        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
+      }
+      await (0, import_auth9.updateProfile)(user, updates);
+    } catch (error) {
+      throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Profile update failed", error);
+    }
+  }
+  async updateEmail(newEmail, password) {
+    try {
+      const user = this.auth.currentUser;
+      if (!user || !user.email) {
+        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
+      }
+      const credential = import_auth9.EmailAuthProvider.credential(user.email, password);
+      await (0, import_auth9.reauthenticateWithCredential)(user, credential);
+      await (0, import_auth9.updateEmail)(user, newEmail);
+    } catch (error) {
+      throw createAuthError("EMAIL_UPDATE_FAILED" /* EMAIL_UPDATE_FAILED */, "Email update failed", error);
+    }
+  }
+  async updatePassword(currentPassword, newPassword) {
+    try {
+      const user = this.auth.currentUser;
+      if (!user || !user.email) {
+        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
+      }
+      const credential = import_auth9.EmailAuthProvider.credential(user.email, currentPassword);
+      await (0, import_auth9.reauthenticateWithCredential)(user, credential);
+      await (0, import_auth9.updatePassword)(user, newPassword);
+    } catch (error) {
+      throw createAuthError("PASSWORD_UPDATE_FAILED" /* PASSWORD_UPDATE_FAILED */, "Password update failed", error);
+    }
+  }
+  async deleteAccount(password) {
+    try {
+      const user = this.auth.currentUser;
+      if (!user || !user.email) {
+        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
+      }
+      const credential = import_auth9.EmailAuthProvider.credential(user.email, password);
+      await (0, import_auth9.reauthenticateWithCredential)(user, credential);
+      await user.delete();
+    } catch (error) {
+      throw createAuthError("ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */, "Account deletion failed", error);
+    }
+  }
+  // State Management
+  getCurrentUser() {
+    return this.auth.currentUser;
+  }
+  onAuthStateChanged(callback) {
+    return this.auth.onAuthStateChanged(callback);
+  }
+  // Note: User document operations should be handled by UserAdapter
+  // These methods are part of IAuthRepository interface but should be implemented separately
+  async createUserDocument(_userId, _data) {
+    throw new Error("createUserDocument should be handled by UserAdapter");
+  }
+  async updateLastLogin(_userId) {
+    throw new Error("updateLastLogin should be handled by UserAdapter");
+  }
+  /**
+   * Handle Firebase Auth errors
+   */
+  handleAuthError(error) {
+    if (error instanceof Error && "code" in error) {
+      const code = error.code;
+      switch (code) {
+        case "auth/user-not-found":
+          return createAuthError("USER_NOT_FOUND" /* USER_NOT_FOUND */, "User not found", error);
+        case "auth/wrong-password":
+        case "auth/invalid-credential":
+          return createAuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, "Invalid credentials", error);
+        case "auth/email-already-in-use":
+          return createAuthError("USER_ALREADY_EXISTS" /* USER_ALREADY_EXISTS */, "Email already in use", error);
+        case "auth/weak-password":
+          return createAuthError("WEAK_PASSWORD" /* WEAK_PASSWORD */, "Password is too weak", error);
+        case "auth/invalid-email":
+          return createAuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, "Invalid email", error);
+        case "auth/user-disabled":
+          return createAuthError("USER_NOT_FOUND" /* USER_NOT_FOUND */, "Account disabled", error);
+        case "auth/too-many-requests":
+          return createAuthError("TOO_MANY_REQUESTS" /* TOO_MANY_REQUESTS */, "Too many requests", error);
+        case "auth/popup-closed-by-user":
+          return createAuthError("OAUTH_CANCELLED" /* OAUTH_CANCELLED */, "Sign in cancelled", error);
+        case "auth/account-exists-with-different-credential":
+          return createAuthError("OAUTH_ACCOUNT_EXISTS" /* OAUTH_ACCOUNT_EXISTS */, "Account exists with different provider", error);
+        case "auth/requires-recent-login":
+          return createAuthError("REAUTHENTICATION_REQUIRED" /* REAUTHENTICATION_REQUIRED */, "Please reauthenticate", error);
+        default:
+          return createAuthError("UNKNOWN" /* UNKNOWN */, `Auth error: ${code}`, error);
+      }
+    }
+    return createAuthError("UNKNOWN" /* UNKNOWN */, "Unknown auth error", error);
+  }
+};
+
+// src/infrastructure/firebase/firestore.adapter.ts
 var import_firestore2 = require("firebase/firestore");
-var FirestoreRepository = class {
-  constructor(db, collectionName) {
-    this.db = db;
-    this.collectionName = collectionName;
-  }
-  getCollection(parentPath) {
-    const fullPath = parentPath ? `${parentPath}/${this.collectionName}` : this.collectionName;
-    return (0, import_firestore2.collection)(this.db, fullPath);
-  }
-  getDocRef(id, parentPath) {
-    const fullPath = parentPath ? `${parentPath}/${this.collectionName}` : this.collectionName;
-    return (0, import_firestore2.doc)(this.db, fullPath, id);
-  }
-  async getById(id, parentPath) {
-    const snap = await (0, import_firestore2.getDoc)(this.getDocRef(id, parentPath));
-    return snap.exists() ? { id: snap.id, ...snap.data() } : null;
-  }
-  async getAll(constraints = [], parentPath) {
-    const q = (0, import_firestore2.query)(this.getCollection(parentPath), ...constraints);
-    const snap = await (0, import_firestore2.getDocs)(q);
-    return snap.docs.map((d) => ({ id: d.id, ...d.data() }));
-  }
-  async create(id, data, parentPath) {
-    await (0, import_firestore2.setDoc)(this.getDocRef(id, parentPath), {
-      ...data,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+var FirestoreAdapter = class {
+  get db() {
+    return getFirebaseDB();
+  }
+  USERS_COLLECTION = "users";
+  async getUser(userId) {
+    try {
+      const docRef = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
+      const snap = await (0, import_firestore2.getDoc)(docRef);
+      if (!snap.exists()) {
+        return null;
+      }
+      return snap.data();
+    } catch (error) {
+      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "User not found", error);
+    }
+  }
+  async getUserByEmail(email) {
+    try {
+      const q = (0, import_firestore2.query)((0, import_firestore2.collection)(this.db, this.USERS_COLLECTION), (0, import_firestore2.where)("profile.email", "==", email));
+      const snap = await (0, import_firestore2.getDocs)(q);
+      if (snap.empty) {
+        return null;
+      }
+      const doc2 = snap.docs[0];
+      return doc2.data();
+    } catch (error) {
+      throw createRepositoryError("QUERY_FAILED" /* QUERY_FAILED */, "Failed to query user", error);
+    }
+  }
+  async createUser(userId, data) {
+    try {
+      const docRef = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
+      await (0, import_firestore2.setDoc)(docRef, data, { merge: true });
+    } catch (error) {
+      throw createRepositoryError("DOCUMENT_INVALID" /* DOCUMENT_INVALID */, "Failed to create user", error);
+    }
+  }
+  async updateUser(userId, data) {
+    try {
+      const docRef = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
+      await (0, import_firestore2.updateDoc)(docRef, {
+        ...data,
+        "profile.updatedAt": Date.now()
+      });
+    } catch (error) {
+      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "Failed to update user", error);
+    }
+  }
+  async deleteUser(userId) {
+    try {
+      const docRef = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
+      await (0, import_firestore2.deleteDoc)(docRef);
+    } catch (error) {
+      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "Failed to delete user", error);
+    }
+  }
+  async updateProfile(userId, updates) {
+    try {
+      const docRef = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
+      const updateData = {
+        "profile.updatedAt": Date.now()
+      };
+      if (updates.displayName !== void 0) {
+        updateData["profile.displayName"] = updates.displayName;
+      }
+      if (updates.photoURL !== void 0) {
+        updateData["profile.photoURL"] = updates.photoURL;
+      }
+      if (updates.phoneNumber !== void 0) {
+        updateData["profile.phoneNumber"] = updates.phoneNumber;
+      }
+      await (0, import_firestore2.updateDoc)(docRef, updateData);
+    } catch (error) {
+      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "Failed to update profile", error);
+    }
+  }
+  async updateSettings(userId, settings) {
+    try {
+      const docRef = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
+      await (0, import_firestore2.updateDoc)(docRef, {
+        settings: {
+          ...settings,
+          updatedAt: Date.now()
+        }
+      });
+    } catch (error) {
+      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "Failed to update settings", error);
+    }
+  }
+  async updateSubscription(userId, subscription) {
+    try {
+      const docRef = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
+      await (0, import_firestore2.updateDoc)(docRef, {
+        subscription: {
+          ...subscription,
+          updatedAt: Date.now()
+        }
+      });
+    } catch (error) {
+      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "Failed to update subscription", error);
+    }
+  }
+  async updateLastLogin(userId) {
+    try {
+      const docRef = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
+      await (0, import_firestore2.updateDoc)(docRef, {
+        "profile.lastLoginAt": Date.now()
+      });
+    } catch (error) {
+      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "Failed to update last login", error);
+    }
+  }
+  async queryUsers(constraints) {
+    try {
+      const q = (0, import_firestore2.query)((0, import_firestore2.collection)(this.db, this.USERS_COLLECTION), ...constraints);
+      const snap = await (0, import_firestore2.getDocs)(q);
+      return snap.docs.map((doc2) => doc2.data());
+    } catch (error) {
+      throw createRepositoryError("QUERY_FAILED" /* QUERY_FAILED */, "Failed to query users", error);
+    }
+  }
+  subscribeToUser(userId, callback, onError) {
+    const docRef = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
+    const unsubscribe = (0, import_firestore2.onSnapshot)(
+      docRef,
+      (snap) => {
+        if (snap.exists()) {
+          callback(snap.data());
+        } else {
+          callback(null);
+        }
+      },
+      (error) => {
+        onError?.(error);
+      }
+    );
+    return unsubscribe;
+  }
+};
+
+// src/infrastructure/firebase/storage.adapter.ts
+var import_storage2 = require("firebase/storage");
+var StorageAdapter = class {
+  get storage() {
+    return getFirebaseStorage();
+  }
+  // Upload Methods
+  async uploadFile(userId, path, file, options) {
+    const storageRef = (0, import_storage2.ref)(this.storage, `users/${userId}/${path}`);
+    const uploadTask = (0, import_storage2.uploadBytesResumable)(storageRef, file);
+    return new Promise((resolve, reject) => {
+      uploadTask.on(
+        "state_changed",
+        (snapshot) => {
+          if (options?.onProgress) {
+            const progress = {
+              bytesTransferred: snapshot.bytesTransferred,
+              totalBytes: snapshot.totalBytes,
+              progress: snapshot.bytesTransferred / snapshot.totalBytes * 100,
+              state: "running"
+            };
+            options.onProgress(progress);
+          }
+        },
+        (error) => reject(createRepositoryError("STORAGE_ERROR" /* STORAGE_ERROR */, "Upload failed", error)),
+        async () => {
+          const downloadURL = await (0, import_storage2.getDownloadURL)(uploadTask.snapshot.ref);
+          const metadata = await (0, import_storage2.getMetadata)(uploadTask.snapshot.ref);
+          resolve({
+            id: uploadTask.snapshot.ref.name,
+            name: metadata.name || uploadTask.snapshot.ref.name,
+            fullPath: metadata.fullPath || uploadTask.snapshot.ref.fullPath,
+            downloadURL,
+            contentType: metadata.contentType || "",
+            size: metadata.size || 0,
+            createdAt: metadata.timeCreated ? new Date(metadata.timeCreated).getTime() : Date.now()
+          });
+        }
+      );
     });
   }
-  async update(id, data, parentPath) {
-    await (0, import_firestore2.updateDoc)(this.getDocRef(id, parentPath), {
-      ...data,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  async uploadImage(userId, file, filename) {
+    const name = filename || `${Date.now()}_${file.name}`;
+    return this.uploadFile(userId, `images/${name}`, file);
+  }
+  async uploadVideo(userId, file, filename) {
+    const name = filename || `${Date.now()}_${file.name}`;
+    return this.uploadFile(userId, `videos/${name}`, file);
+  }
+  async uploadDocument(userId, file, filename) {
+    const name = filename || `${Date.now()}_${file.name}`;
+    return this.uploadFile(userId, `documents/${name}`, file);
+  }
+  async uploadProfilePicture(userId, file) {
+    const storageRef = (0, import_storage2.ref)(this.storage, `users/${userId}/profile/${Date.now()}_${file.name}`);
+    await (0, import_storage2.uploadBytes)(storageRef, file);
+    const downloadURL = await (0, import_storage2.getDownloadURL)(storageRef);
+    return {
+      id: storageRef.name,
+      name: file.name,
+      fullPath: storageRef.fullPath,
+      downloadURL,
+      contentType: file.type,
+      size: file.size,
+      createdAt: Date.now()
+    };
+  }
+  // Download Methods
+  async getDownloadURL(path) {
+    try {
+      const storageRef = (0, import_storage2.ref)(this.storage, path);
+      return await (0, import_storage2.getDownloadURL)(storageRef);
+    } catch (error) {
+      throw createRepositoryError("FILE_NOT_FOUND" /* FILE_NOT_FOUND */, "File not found", error);
+    }
+  }
+  // Delete Methods
+  async deleteFile(path) {
+    try {
+      const storageRef = (0, import_storage2.ref)(this.storage, path);
+      await (0, import_storage2.deleteObject)(storageRef);
+    } catch (error) {
+      throw createRepositoryError("FILE_NOT_FOUND" /* FILE_NOT_FOUND */, "File not found", error);
+    }
+  }
+  async deleteUserFiles(userId) {
+    try {
+      const userRef = (0, import_storage2.ref)(this.storage, `users/${userId}`);
+      const result = await (0, import_storage2.listAll)(userRef);
+      for (const prefix of result.prefixes) {
+        const prefixResult = await (0, import_storage2.listAll)(prefix);
+        await Promise.all(prefixResult.items.map((item) => (0, import_storage2.deleteObject)(item)));
+      }
+      await Promise.all(result.items.map((item) => (0, import_storage2.deleteObject)(item)));
+    } catch (error) {
+      throw createRepositoryError("STORAGE_ERROR" /* STORAGE_ERROR */, "Failed to delete user files", error);
+    }
+  }
+  async deleteImage(userId, filename) {
+    await this.deleteFile(`users/${userId}/images/${filename}`);
+  }
+  async deleteVideo(userId, filename) {
+    await this.deleteFile(`users/${userId}/videos/${filename}`);
+  }
+  async deleteProfilePicture(userId, filename) {
+    await this.deleteFile(`users/${userId}/profile/${filename}`);
+  }
+  // List Methods
+  async listUserFiles(userId, path) {
+    const userRef = (0, import_storage2.ref)(this.storage, path ? `users/${userId}/${path}` : `users/${userId}`);
+    const result = await (0, import_storage2.listAll)(userRef);
+    const urls = await Promise.all(result.items.map((item) => (0, import_storage2.getDownloadURL)(item)));
+    return urls;
+  }
+  async listUserImages(userId) {
+    return this.listUserFiles(userId, "images");
+  }
+  async listUserVideos(userId) {
+    return this.listUserFiles(userId, "videos");
+  }
+  // Metadata
+  async getFileMetadata(path) {
+    try {
+      const storageRef = (0, import_storage2.ref)(this.storage, path);
+      const metadata = await (0, import_storage2.getMetadata)(storageRef);
+      return {
+        id: storageRef.name,
+        name: metadata.name,
+        fullPath: metadata.fullPath,
+        contentType: metadata.contentType || "application/octet-stream",
+        size: metadata.size,
+        createdAt: metadata.timeCreated ? new Date(metadata.timeCreated).getTime() : Date.now(),
+        updatedAt: metadata.updated ? new Date(metadata.updated).getTime() : Date.now(),
+        userId: this.extractUserId(path) || "unknown",
+        type: this.extractFileType(metadata.contentType || "")
+      };
+    } catch (error) {
+      throw createRepositoryError("FILE_NOT_FOUND" /* FILE_NOT_FOUND */, "File not found", error);
+    }
+  }
+  async queryFiles(userId, _filters) {
+    const userRef = (0, import_storage2.ref)(this.storage, `users/${userId}`);
+    const result = await (0, import_storage2.listAll)(userRef);
+    const files = await Promise.all(
+      result.items.map(async (item) => {
+        const metadata = await (0, import_storage2.getMetadata)(item);
+        return {
+          id: item.name,
+          name: metadata.name,
+          fullPath: metadata.fullPath,
+          contentType: metadata.contentType || "application/octet-stream",
+          size: metadata.size,
+          createdAt: metadata.timeCreated ? new Date(metadata.timeCreated).getTime() : Date.now(),
+          updatedAt: metadata.updated ? new Date(metadata.updated).getTime() : Date.now(),
+          userId,
+          type: this.extractFileType(metadata.contentType || "")
+        };
+      })
+    );
+    return {
+      files,
+      totalCount: files.length,
+      hasMore: false
+    };
+  }
+  async getStorageStats(userId) {
+    const { files, totalCount } = await this.queryFiles(userId);
+    const stats = {
+      totalFiles: totalCount,
+      totalSize: files.reduce((sum, file) => sum + file.size, 0),
+      filesByType: {
+        image: 0,
+        video: 0,
+        audio: 0,
+        document: 0,
+        other: 0
+      },
+      filesByCategory: {
+        profile: 0,
+        content: 0,
+        document: 0,
+        attachment: 0,
+        backup: 0
+      }
+    };
+    files.forEach((file) => {
+      stats.filesByType[file.type]++;
+      stats.lastUploadAt = Math.max(stats.lastUploadAt || 0, file.createdAt);
     });
+    return stats;
+  }
+  // Validation
+  validateFile(file, options) {
+    const maxSizeBytes = options?.maxSizeBytes || (options?.maxSizeMB ? options.maxSizeMB * 1024 * 1024 : 10 * 1024 * 1024);
+    if (file.size > maxSizeBytes) {
+      return false;
+    }
+    if (options?.allowedTypes && !options.allowedTypes.includes(file.type)) {
+      return false;
+    }
+    return true;
+  }
+  isImageFile(file) {
+    return file.type.startsWith("image/");
+  }
+  isVideoFile(file) {
+    return file.type.startsWith("video/");
   }
-  async delete(id, parentPath) {
-    await (0, import_firestore2.deleteDoc)(this.getDocRef(id, parentPath));
+  isDocumentFile(file) {
+    const docTypes = [
+      "application/pdf",
+      "application/msword",
+      "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      "application/vnd.ms-excel",
+      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      "text/plain"
+    ];
+    return docTypes.includes(file.type);
+  }
+  // Utility Methods
+  generateUniqueFilename(originalName) {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 8);
+    const extension = this.getFileExtension(originalName);
+    return `${timestamp}_${random}.${extension}`;
+  }
+  getFileExtension(filename) {
+    return filename.slice((filename.lastIndexOf(".") - 1 >>> 0) + 2);
+  }
+  // Helper Methods
+  extractUserId(path) {
+    const match = path.match(/users\/([^\/]+)/);
+    return match ? match[1] : "";
+  }
+  extractFileType(contentType) {
+    if (contentType.startsWith("image/")) return "image";
+    if (contentType.startsWith("video/")) return "video";
+    if (contentType.startsWith("audio/")) return "audio";
+    if (contentType.includes("pdf") || contentType.includes("document") || contentType.includes("text")) {
+      return "document";
+    }
+    return "other";
   }
 };
 
 // src/infrastructure/utils/storage.util.ts
-var import_storage2 = require("firebase/storage");
-async function uploadFile(storage, path, file) {
-  const storageRef = (0, import_storage2.ref)(storage, path);
-  await (0, import_storage2.uploadBytes)(storageRef, file);
-  const url = await (0, import_storage2.getDownloadURL)(storageRef);
+var import_storage3 = require("firebase/storage");
+async function uploadFile(storage2, path, file) {
+  const storageRef = (0, import_storage3.ref)(storage2, path);
+  await (0, import_storage3.uploadBytes)(storageRef, file);
+  const url = await (0, import_storage3.getDownloadURL)(storageRef);
   return { url, path };
 }
-async function uploadBase64(storage, path, base64, mimeType = "image/jpeg") {
-  const storageRef = (0, import_storage2.ref)(storage, path);
+async function uploadBase64(storage2, path, base64, mimeType = "image/jpeg") {
+  const storageRef = (0, import_storage3.ref)(storage2, path);
   const dataUrl = base64.startsWith("data:") ? base64 : `data:${mimeType};base64,${base64}`;
-  await (0, import_storage2.uploadString)(storageRef, dataUrl, "data_url");
-  const url = await (0, import_storage2.getDownloadURL)(storageRef);
+  await (0, import_storage3.uploadString)(storageRef, dataUrl, "data_url");
+  const url = await (0, import_storage3.getDownloadURL)(storageRef);
   return { url, path };
 }
-async function deleteFile(storage, path) {
-  await (0, import_storage2.deleteObject)((0, import_storage2.ref)(storage, path));
+async function deleteFile(storage2, path) {
+  await (0, import_storage3.deleteObject)((0, import_storage3.ref)(storage2, path));
 }
 
 // src/presentation/hooks/useFirebaseAuth.ts
 var import_react = require("react");
-var import_auth2 = require("firebase/auth");
+var import_auth12 = require("firebase/auth");
 function mapUser(u) {
   return {
     uid: u.uid,
@@ -120,56 +1723,56 @@ function mapUser(u) {
     emailVerified: u.emailVerified
   };
 }
-function useFirebaseAuth(auth, options) {
+function useFirebaseAuth(auth2, options) {
   const [user, setUser] = (0, import_react.useState)(null);
   const [loading, setLoading] = (0, import_react.useState)(true);
   (0, import_react.useEffect)(() => {
-    const unsub = (0, import_auth2.onAuthStateChanged)(auth, (firebaseUser) => {
+    const unsub = (0, import_auth12.onAuthStateChanged)(auth2, (firebaseUser) => {
       const mapped = firebaseUser ? mapUser(firebaseUser) : null;
       setUser(mapped);
       setLoading(false);
       options?.onUserChange?.(mapped);
     });
     return unsub;
-  }, [auth, options]);
+  }, [auth2, options]);
   const signIn = (0, import_react.useCallback)(
-    (email, password) => (0, import_auth2.signInWithEmailAndPassword)(auth, email, password),
-    [auth]
+    (email, password) => (0, import_auth12.signInWithEmailAndPassword)(auth2, email, password),
+    [auth2]
   );
   const signUp = (0, import_react.useCallback)(
     async (email, password, name) => {
-      const cred = await (0, import_auth2.createUserWithEmailAndPassword)(auth, email, password);
-      if (name && cred.user) await (0, import_auth2.updateProfile)(cred.user, { displayName: name });
+      const cred = await (0, import_auth12.createUserWithEmailAndPassword)(auth2, email, password);
+      if (name && cred.user) await (0, import_auth12.updateProfile)(cred.user, { displayName: name });
       return cred;
     },
-    [auth]
+    [auth2]
   );
-  const signOut = (0, import_react.useCallback)(() => (0, import_auth2.signOut)(auth), [auth]);
+  const signOut = (0, import_react.useCallback)(() => (0, import_auth12.signOut)(auth2), [auth2]);
   const updateUserProfile = (0, import_react.useCallback)(
     async (name, photoURL) => {
-      if (!auth.currentUser) throw new Error("No authenticated user");
-      await (0, import_auth2.updateProfile)(auth.currentUser, {
+      if (!auth2.currentUser) throw new Error("No authenticated user");
+      await (0, import_auth12.updateProfile)(auth2.currentUser, {
         displayName: name,
         ...photoURL !== void 0 && { photoURL }
       });
     },
-    [auth]
+    [auth2]
   );
   const updateUserPassword = (0, import_react.useCallback)(
     async (newPassword) => {
-      if (!auth.currentUser) throw new Error("No authenticated user");
-      await (0, import_auth2.updatePassword)(auth.currentUser, newPassword);
+      if (!auth2.currentUser) throw new Error("No authenticated user");
+      await (0, import_auth12.updatePassword)(auth2.currentUser, newPassword);
     },
-    [auth]
+    [auth2]
   );
   const resetPassword = (0, import_react.useCallback)(
-    (email) => (0, import_auth2.sendPasswordResetEmail)(auth, email),
-    [auth]
+    (email) => (0, import_auth12.sendPasswordResetEmail)(auth2, email),
+    [auth2]
   );
   const getIdToken = (0, import_react.useCallback)(async () => {
-    if (!auth.currentUser) throw new Error("No authenticated user");
-    return auth.currentUser.getIdToken();
-  }, [auth]);
+    if (!auth2.currentUser) throw new Error("No authenticated user");
+    return auth2.currentUser.getIdToken();
+  }, [auth2]);
   return {
     user,
     loading,
@@ -185,9 +1788,45 @@ function useFirebaseAuth(auth, options) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  FirestoreRepository,
+  AuthAdapter,
+  AuthError,
+  AuthErrorCode,
+  DeleteAccountUseCase,
+  Email,
+  FileErrorCode,
+  FilePath,
+  FirestoreAdapter,
+  RepositoryError,
+  RepositoryErrorCode,
+  ResetPasswordUseCase,
+  SignInUseCase,
+  SignInWithGoogleUseCase,
+  SignOutUseCase,
+  SignUpUseCase,
+  StorageAdapter,
+  Timestamp,
+  USER_COLLECTIONS,
+  USER_SUBCOLLECTIONS,
+  UpdateProfileUseCase,
+  UserId,
+  analytics,
+  app,
+  auth,
+  createAuthError,
+  createRepositoryError,
+  db,
   deleteFile,
+  functions,
+  getFirebaseAnalytics,
+  getFirebaseApp,
+  getFirebaseAuth,
+  getFirebaseDB,
+  getFirebaseFunctions,
+  getFirebaseInstances,
+  getFirebaseStorage,
   initializeFirebase,
+  serverTimestamp,
+  storage,
   uploadBase64,
   uploadFile,
   useFirebaseAuth