falconhub-apilibrary 1.1.0

package/dist/index.mjs

@@ -0,0 +1,825 @@
+// src/types/ErrorResponse.ts
+var ErrorResponse = class extends Error {
+  constructor(message, statusCode, responseData) {
+    super(message);
+    this.statusCode = statusCode;
+    this.responseData = responseData;
+    this.name = "FalconHUB API Error";
+  }
+};
+
+// src/core/API.ts
+var API = class {
+  constructor(properties, cryptoService, authInterceptor, getAccessToken, getRefreshToken) {
+    this.properties = properties;
+    this.cryptoService = cryptoService;
+    this.getAccessToken = getAccessToken;
+    this.getRefreshToken = getRefreshToken;
+    this.authInterceptor = authInterceptor;
+  }
+  /**
+   * Ejecuta una request HTTP al API
+   *
+   * @param options - Opciones de la request
+   * @returns Respuesta parseada del tipo esperado
+   */
+  async apiExecute(options) {
+    const {
+      endpoint,
+      method,
+      body,
+      requiresSignature,
+      requiresAuth,
+      timeStamp
+    } = options;
+    const context = {
+      requestId: this.cryptoService.generateUniqueId(),
+      startTime: Date.now(),
+      retryCount: 0,
+      metadata: {}
+    };
+    try {
+      const url = `${this.properties.url}/${endpoint}`;
+      const headers = {};
+      if (body && method !== "GET") {
+        headers["Content-Type"] = "application/json";
+      }
+      ;
+      const accessToken = this.getAccessToken();
+      if (accessToken) {
+        headers["Authorization"] = `Bearer ${accessToken}`;
+      }
+      ;
+      const newTimeStamp = timeStamp || (/* @__PURE__ */ new Date()).toString();
+      headers["X-Timestamp"] = newTimeStamp;
+      let bodyString;
+      if (body && method !== "GET") {
+        bodyString = JSON.stringify(body);
+      }
+      ;
+      if (requiresSignature && bodyString) {
+        try {
+          const refreshToken = this.getRefreshToken();
+          if (refreshToken) {
+            const signature = this.cryptoService.genSignature(
+              bodyString,
+              newTimeStamp,
+              refreshToken
+            );
+            if (signature) {
+              headers["X-Signature"] = signature;
+            }
+            ;
+          }
+          ;
+        } catch (error) {
+          throw new ErrorResponse(
+            "Failed to generate request signature.",
+            401
+          );
+        }
+        ;
+      }
+      ;
+      const requestConfig = {
+        url,
+        method,
+        headers,
+        body: bodyString,
+        requiresAuth,
+        requiresSignature
+      };
+      const modifiedConfig = this.authInterceptor ? await this.authInterceptor.onRequest(requestConfig, context) : requestConfig;
+      const requestInit = {
+        method: modifiedConfig.method,
+        headers: modifiedConfig.headers,
+        mode: "cors",
+        credentials: "omit"
+      };
+      if (bodyString) {
+        requestInit.body = bodyString;
+      }
+      ;
+      const response = await fetch(
+        modifiedConfig.url,
+        requestInit
+      );
+      if (response.ok) {
+        const newAccessToken = response.headers.get("X-New-Access-Token");
+        const newRefreshToken = response.headers.get("X-New-Refresh-Token");
+        if (newAccessToken || newRefreshToken) {
+          this.properties.onTokensRefreshed?.({
+            accessToken: newAccessToken,
+            refreshToken: newRefreshToken
+          });
+        }
+        ;
+        const contentType = response.headers.get("Content-Type");
+        if (contentType && contentType.includes("application/json")) {
+          const responseText = await response.text();
+          return JSON.parse(responseText);
+        }
+        ;
+        return void 0;
+      } else {
+        await this.handleErrorResponse(response);
+      }
+      ;
+    } catch (error) {
+      if (error instanceof ErrorResponse) {
+        throw error;
+      }
+      ;
+      throw new ErrorResponse(
+        "Unexpected error occurred during API request.",
+        500
+      );
+    }
+    ;
+  }
+  /**
+   * Maneja errores HTTP y lanza excepciones apropiadas
+   */
+  async handleErrorResponse(response) {
+    const statusCode = response.status;
+    let errorMessage = `Error ${statusCode}`;
+    let responseData = null;
+    try {
+      const contentType = response.headers.get("Content-Type");
+      if (contentType && contentType.includes("application/json")) {
+        responseData = await response.json();
+        errorMessage = responseData.message || responseData.error || errorMessage;
+      } else {
+        errorMessage = await response.text();
+      }
+      ;
+    } catch (error) {
+    }
+    ;
+    switch (statusCode) {
+      case 401:
+        const authError = new ErrorResponse(
+          "Unauthorized access.",
+          401,
+          responseData
+        );
+        this.properties.onAuthError?.(authError);
+        throw authError;
+      case 403:
+        throw new ErrorResponse(
+          "No tienes permisos para realizar esta acci\xF3n.",
+          403,
+          responseData
+        );
+      case 404:
+        throw new ErrorResponse(
+          "Recurso no encontrado.",
+          404,
+          responseData
+        );
+      case 422:
+        throw new ErrorResponse(
+          errorMessage || "Datos de entrada inv\xE1lidos.",
+          422,
+          responseData
+        );
+      case 500:
+        throw new ErrorResponse(
+          "Error interno del servidor.",
+          500,
+          responseData
+        );
+      default:
+        throw new ErrorResponse(
+          errorMessage,
+          statusCode,
+          responseData
+        );
+    }
+    ;
+  }
+  //#region REQUEST METHODS
+  async executeGET(endpoint, requiresAuth = false) {
+    return this.apiExecute({
+      endpoint,
+      method: "GET",
+      requiresAuth,
+      requiresSignature: false
+    });
+  }
+  async executePOST(endpoint, body, requiresAuth = true, requiresSignature = true) {
+    return this.apiExecute({
+      endpoint,
+      method: "POST",
+      body,
+      requiresAuth,
+      requiresSignature
+    });
+  }
+  async executePATCH(endpoint, body, requiresAuth = true, requiresSignature = true) {
+    return this.apiExecute({
+      endpoint,
+      method: "PATCH",
+      body,
+      requiresAuth,
+      requiresSignature
+    });
+  }
+  async executeDELETE(endpoint, body, requiresAuth = true, requiresSignature = false) {
+    return this.apiExecute({
+      endpoint,
+      method: "DELETE",
+      body,
+      requiresAuth,
+      requiresSignature
+    });
+  }
+  async executePUT(endpoint, body, requiresAuth = true, requiresSignature = true) {
+    return this.apiExecute({
+      endpoint,
+      method: "PUT",
+      body,
+      requiresAuth,
+      requiresSignature
+    });
+  }
+  async executePublicRequest(endpoint, method, body, timestamp) {
+    return this.apiExecute({
+      endpoint,
+      method,
+      body,
+      requiresAuth: false,
+      requiresSignature: false,
+      timeStamp: timestamp
+    });
+  }
+  //#endregion
+};
+
+// src/core/CryptoService.ts
+import * as CryptoJS from "crypto-js";
+var CryptoService = class {
+  /**
+   * Encripta el texto plano utilizando AES con una clave derivada del secretWord y el timestamp
+   *
+   * @param plaintText -- Texto plano a encriptar
+   * @param secretWord - Palabra secreta utilizada para derivar la clave
+   * @param timestamp - Timestamp actual
+   * @returns Texto encriptado en formato Base64
+   */
+  encrypt(plaintText, secretWord, timestamp) {
+    const fullKey = `${secretWord}:${timestamp}`;
+    const key = CryptoJS.SHA256(fullKey);
+    const iv = CryptoJS.lib.WordArray.random(16);
+    const encrypted = CryptoJS.AES.encrypt(plaintText, key, {
+      iv,
+      mode: CryptoJS.mode.CBC,
+      padding: CryptoJS.pad.Pkcs7
+    });
+    const ivAndCipher = iv.concat(encrypted.ciphertext);
+    return CryptoJS.enc.Base64.stringify(ivAndCipher);
+  }
+  /**
+   * Genera la firma Signature para las operaciones de tipo POST
+   *
+   * @param body - Cuerpo de la solicitud
+   * @param timestamp - Timestamp actual
+   * @param refreshToken - Refresh token del usuario
+   * @returns Firma signature en formato Base64
+   */
+  genSignature(body, timestamp, refreshToken) {
+    const message = `${body}:${timestamp}`;
+    const hmac = CryptoJS.HmacSHA256(message, refreshToken);
+    return CryptoJS.enc.Base64.stringify(hmac);
+  }
+  /**
+    * Desencripta texto usando AES-256-CBC
+    *
+    * @param encryptedBase64 - Texto encriptado en base64
+    * @param secret - Clave secreta
+    * @param timestamp - Timestamp usado en la encriptación
+    * @returns Texto desencriptado
+  */
+  decrypt(encryptedText, secretWord, timestamp) {
+    try {
+      const fullKey = `${secretWord}:${timestamp}`;
+      const key = CryptoJS.SHA256(fullKey);
+      const ivAndCipher = CryptoJS.enc.Base64.parse(encryptedText);
+      const iv = CryptoJS.lib.WordArray.create(ivAndCipher.words.slice(0, 4));
+      const ciphertext = CryptoJS.lib.WordArray.create(
+        ivAndCipher.words.slice(4),
+        ivAndCipher.sigBytes - 16
+      );
+      const decrypted = CryptoJS.AES.decrypt(
+        { ciphertext },
+        key,
+        {
+          iv,
+          mode: CryptoJS.mode.CBC,
+          padding: CryptoJS.pad.Pkcs7
+        }
+      );
+      return CryptoJS.enc.Utf8.stringify(decrypted);
+    } catch (error) {
+      throw new Error("Decryption failed, ex:" + error);
+    }
+  }
+  /**
+  * Verifica una firma HMAC-SHA256 (útil para testing o validación)
+  *
+  * @param body - Cuerpo original
+  * @param timestamp - Timestamp original
+  * @param refreshToken - Token usado como clave
+  * @param signature - Firma a verificar
+  * @returns true si la firma es válida
+  */
+  verifySignature(body, timestamp, refreshToken, signature) {
+    try {
+      const expectedSignature = this.genSignature(body, timestamp, refreshToken);
+      return expectedSignature === signature;
+    } catch {
+      return false;
+    }
+  }
+  /**
+  * Genera un hash SHA256 de un texto (útil para fingerprints)
+  *
+  * @param text - Texto a hashear
+  * @returns Hash en formato hexadecimal
+  */
+  sha256(text) {
+    return CryptoJS.SHA256(text).toString(CryptoJS.enc.Hex);
+  }
+  /**
+   * Genera un identificador único basado en timestamp y random
+   * (útil para request IDs)
+   *
+   * @returns ID único
+   */
+  generateUniqueId() {
+    const timestamp = Date.now().toString(36);
+    const randomPart = Math.random().toString(36).substring(2, 15);
+    return `${timestamp}-${randomPart}`;
+  }
+};
+
+// src/core/TokenManager.ts
+var TokenManager = class {
+  constructor(onTokensChanged, onSessionExpiring, onSessionExpired) {
+    this.tokens = null;
+    this.sessionCheckInterval = null;
+    this.hasNotifiedExpiring = false;
+    this.onTokensChanged = onTokensChanged;
+    this.onSessionExpiring = onSessionExpiring;
+    this.onSessionExpired = onSessionExpired;
+  }
+  /**
+   * Guarda los tokens de autenticación y dispara el callback onTokensChanged.
+   */
+  setTokens(tokens) {
+    this.tokens = tokens;
+    this.hasNotifiedExpiring = false;
+    this.onTokensChanged?.(this.tokens);
+    if (!tokens.rememberMe) {
+      this.startExpirationCheck();
+    } else {
+      this.stopExpirationCheck();
+    }
+    ;
+  }
+  /**
+   * Obtiene los tokens de autenticación almacenados.
+   */
+  getTokens() {
+    return this.tokens;
+  }
+  /**
+   * Limpia los tokens de autenticación almacenados y dispara el callback onTokensChanged.
+   */
+  clearTokens() {
+    this.stopExpirationCheck();
+    this.tokens = null;
+    this.onTokensChanged?.(this.tokens);
+  }
+  /**
+   * Valida si existen tokens y si el access token no ha expirado.
+   */
+  hasValidTokens() {
+    if (!this.tokens) return false;
+    const now = Date.now();
+    const expiresAt = this.tokens.expiresAt.getTime();
+    return now < expiresAt;
+  }
+  /**
+   * Valida si el access token expirará dentro del umbral especificado (en minutos).
+   */
+  isTokenExpiringSoon(thresholdMinutes) {
+    if (!this.tokens) return false;
+    const now = Date.now();
+    const expiresAt = this.tokens.expiresAt.getTime();
+    const thresholdMs = thresholdMinutes * 60 * 1e3;
+    const timeLeft = expiresAt - now;
+    return timeLeft > 0 && timeLeft <= thresholdMs;
+  }
+  /**
+   * Obtiene el tiempo restante hasta la expiración del access token en milisegundos.
+   */
+  getTimeUntilExpiry() {
+    if (!this.tokens) return null;
+    const now = Date.now();
+    const expiresAt = this.tokens.expiresAt.getTime();
+    const timeLeft = Math.max(0, expiresAt - now);
+    return timeLeft;
+  }
+  /**
+   * Obtiene el access token almacenado.
+   */
+  getAccessToken() {
+    return this.tokens ? this.tokens.accessToken : null;
+  }
+  /**
+   * Obtiene el refresh token almacenado.
+   */
+  getRefreshToken() {
+    return this.tokens ? this.tokens.refreshToken : null;
+  }
+  /**
+   * Verifica si el auto-refresh debe ejecutarse
+   * Solo si el usuario activó "rememberMe" durante el login
+   */
+  shouldAutoRefresh() {
+    if (!this.tokens) return false;
+    return this.tokens.rememberMe === true;
+  }
+  /**
+   * Inicia el monitoreo de expiración para sesiones sin rememberMe
+   * - Notifica cuando quedan 5 minutos (onSessionExpiring)
+   * - Ejecuta logout cuando queda 1 minuto (onSessionExpired)
+   */
+  startExpirationCheck() {
+    this.stopExpirationCheck();
+    this.sessionCheckInterval = setInterval(async () => {
+      if (!this.tokens) {
+        this.stopExpirationCheck();
+        return;
+      }
+      ;
+      const timeLeft = this.getTimeUntilExpiry();
+      if (timeLeft === null) return;
+      const minutesLeft = Math.floor(timeLeft / (60 * 1e3));
+      if (minutesLeft <= 5 && minutesLeft > 1 && !this.hasNotifiedExpiring) {
+        this.hasNotifiedExpiring = true;
+        this.onSessionExpiring?.(minutesLeft);
+      }
+      ;
+      if (minutesLeft <= 1) {
+        this.stopExpirationCheck();
+        if (this.onSessionExpired) {
+          await this.onSessionExpired();
+        }
+        ;
+      }
+      ;
+    }, 6e4);
+  }
+  /**
+   * Detiene el monitoreo de expiración
+   */
+  stopExpirationCheck() {
+    if (this.sessionCheckInterval) {
+      clearInterval(this.sessionCheckInterval);
+      this.sessionCheckInterval = null;
+    }
+    ;
+  }
+};
+
+// src/core/interceptors/AuthInterceptor.ts
+var AuthInterceptor = class {
+  constructor(config) {
+    this.name = "AuthInterceptor";
+    this.refreshPromise = null;
+    this.isRefreshing = false;
+    this.config = {
+      enabled: config.enabled ?? true,
+      thresholdMinutes: config.thresholdMinutes ?? 5,
+      isTokenExpiringSoon: config.isTokenExpiringSoon,
+      hasValidTokens: config.hasValidTokens,
+      shouldAutoRefresh: config.shouldAutoRefresh,
+      refreshSession: config.refreshSession
+    };
+  }
+  async onRequest(config, context) {
+    if (!config.requiresAuth || !this.config.enabled) {
+      return config;
+    }
+    ;
+    if (!this.config.hasValidTokens()) {
+      return config;
+    }
+    ;
+    if (!this.config.shouldAutoRefresh()) {
+      return config;
+    }
+    ;
+    if (this.config.isTokenExpiringSoon()) {
+      try {
+        if (this.isRefreshing && this.refreshPromise) {
+          await this.refreshPromise;
+        } else {
+          this.isRefreshing = true;
+          this.refreshPromise = this.config.refreshSession();
+          await this.refreshPromise;
+          this.isRefreshing = false;
+          this.refreshPromise = null;
+        }
+        ;
+      } catch (error) {
+        this.isRefreshing = false;
+        this.refreshPromise = null;
+      }
+      ;
+    }
+    ;
+    return config;
+  }
+  updateConfig(config) {
+    this.config = {
+      ...this.config,
+      ...config
+    };
+  }
+  reset() {
+    this.isRefreshing = false;
+    this.refreshPromise = null;
+  }
+};
+
+// src/services/AuthService.ts
+var AuthService = class {
+  constructor(serviceProperties, tokenManager, cryptoService, api) {
+    this.api = api;
+    this.crytpoService = cryptoService;
+    this.tokenManager = tokenManager;
+    this.serviceProperties = serviceProperties;
+  }
+  /**
+   * Login con las credenciales proporcionadas
+   * @param credentials - Objeto con email, password y rememberMe
+   * @returns Retorna el cuerpo de respuesta del login.
+   */
+  async login(credentials) {
+    const timestamp = Date.now().toString();
+    const encryptedEmail = this.crytpoService.encrypt(
+      credentials.email,
+      `${this.serviceProperties.originRequest}_${this.serviceProperties.domain}`,
+      timestamp
+    );
+    const encryptedPassword = this.crytpoService.encrypt(
+      credentials.password,
+      `${this.serviceProperties.originRequest}_${this.serviceProperties.domain}`,
+      timestamp
+    );
+    const loginData = {
+      email: encryptedEmail,
+      password: encryptedPassword,
+      rememberMe: credentials.rememberMe
+    };
+    const response = await this.api.executePublicRequest(
+      "oauth/login",
+      "POST",
+      loginData,
+      timestamp
+    );
+    if (!response) {
+      throw new ErrorResponse("No response from server");
+    }
+    ;
+    if (response.success) {
+      const data = response.data;
+      const expiresIn = parseInt(data.expiresIn.replace("s", ""));
+      const expiresAt = new Date(Date.now() + expiresIn * 1e3);
+      const tokens = {
+        accessToken: data.accessToken,
+        refreshToken: data.refreshToken,
+        expiresAt,
+        rememberMe: credentials.rememberMe
+      };
+      await this.tokenManager.setTokens(tokens);
+      this.serviceProperties.onTokensUpdated?.(tokens);
+      const responseData = {
+        success: data.accessToken ? true : false,
+        data,
+        message: response.message,
+        responseTime: "3s"
+      };
+      return responseData;
+    }
+    return response;
+  }
+  /**
+   * Valida la sesión actual y retorna información de expiración
+   *
+   * El servidor puede responder de 2 formas:
+   * 1. Sesión renovada (sliding window): retorna nuevos tokens
+   * 2. Sesión válida: retorna info de expiración sin renovar
+   */
+  async validateSession() {
+    const response = await this.api.executePOST(
+      "oauth/validateSession"
+    );
+    if (!response) {
+      throw new ErrorResponse("No response from server");
+    }
+    ;
+    if (response.success && response.data) {
+      const respData = response.data;
+      if ("expiresIn" in respData && respData.expiresIn) {
+        const sessionData = respData;
+        const expiresIn = parseInt(sessionData.expiresIn.replace("s", ""));
+        const expiresAt = new Date(Date.now() + expiresIn * 1e3);
+        const currentTokens = this.tokenManager.getTokens();
+        const rememberMe = currentTokens?.rememberMe ?? sessionData.isRemembered;
+        const tokens = {
+          accessToken: sessionData.accessToken,
+          refreshToken: sessionData.refreshToken,
+          expiresAt,
+          rememberMe
+        };
+        this.tokenManager.setTokens(tokens);
+        this.serviceProperties.onTokensUpdated?.(tokens);
+      } else if ("expiresAt" in respData && respData.expiresAt) {
+        const sessionData = respData;
+        if (sessionData.remainingMinutes <= 5 && sessionData.remainingMinutes > 1) {
+          this.serviceProperties.onSessionExpiring?.(sessionData.remainingMinutes);
+        } else if (sessionData.remainingMinutes <= 1) {
+          if (this.serviceProperties.onSessionExpired) {
+            await this.serviceProperties.onSessionExpired();
+          }
+        }
+      }
+    }
+    ;
+    return response;
+  }
+  /**
+   * Refresca los tokens usando el refresh token
+   */
+  async refreshTokens(rememberMe) {
+    const refreshToken = this.tokenManager.getRefreshToken();
+    if (!refreshToken) {
+      throw new ErrorResponse("No refresh token available");
+    }
+    ;
+    const response = await this.api.executePublicRequest(
+      "oauth/refresh",
+      "POST",
+      { refreshToken }
+    );
+    if (!response) {
+      throw new ErrorResponse("No response from server");
+    }
+    ;
+    if (response.success) {
+      const sessionData = response.data;
+      const currentTokens = this.tokenManager.getTokens();
+      const shouldRemember = rememberMe ?? currentTokens?.rememberMe ?? false;
+      const expiresIn = parseInt(sessionData.expiresIn.replace("s", ""));
+      const expiresAt = new Date(Date.now() + expiresIn * 1e3);
+      const tokens = {
+        accessToken: sessionData.accessToken,
+        refreshToken: sessionData.refreshToken,
+        expiresAt,
+        rememberMe: shouldRemember
+      };
+      this.tokenManager.setTokens(tokens);
+      this.serviceProperties.onTokensUpdated?.(tokens);
+    }
+    ;
+    return response;
+  }
+  /**
+   * Cierra sesión: notifica al servidor y limpia tokens
+   */
+  async logout() {
+    try {
+      await this.api.executePOST("oauth/logout");
+    } catch (error) {
+    }
+    ;
+    this.tokenManager.clearTokens();
+    this.serviceProperties.onTokensUpdated?.(null);
+  }
+  /**
+   * Verifica si el usuario está autenticado
+   */
+  isAuthenticated() {
+    return this.tokenManager.hasValidTokens();
+  }
+  /**
+   * Obtiene los tokens actuales
+   */
+  getTokens() {
+    return this.tokenManager.getTokens();
+  }
+};
+
+// src/FalconHUBSDK.ts
+var FalconHUBSDK = class {
+  constructor(serviceProperties) {
+    this.serviceProperties = serviceProperties;
+    this.cryptoService = new CryptoService();
+    this.tokenManager = new TokenManager(
+      this.serviceProperties.onTokensUpdated,
+      this.serviceProperties.onSessionExpiring,
+      async () => {
+        await this.auth.logout();
+      }
+    );
+    const autoRefreshConfig = this.normalizeAutoRefreshConfig(this.serviceProperties.autoRefresh);
+    if (autoRefreshConfig.enabled) {
+      this.authInterceptor = new AuthInterceptor({
+        enabled: true,
+        thresholdMinutes: autoRefreshConfig.thresholdMinutes,
+        isTokenExpiringSoon: () => this.tokenManager.isTokenExpiringSoon(autoRefreshConfig.thresholdMinutes),
+        hasValidTokens: () => this.tokenManager.hasValidTokens(),
+        shouldAutoRefresh: () => this.tokenManager.shouldAutoRefresh(),
+        refreshSession: async () => {
+          await this.auth.validateSession();
+        }
+      });
+    } else {
+      this.authInterceptor = null;
+    }
+    this.api = new API(
+      this.serviceProperties,
+      this.cryptoService,
+      this.authInterceptor,
+      () => this.tokenManager.getAccessToken(),
+      () => this.tokenManager.getRefreshToken()
+    );
+    this.auth = new AuthService(
+      this.serviceProperties,
+      this.tokenManager,
+      this.cryptoService,
+      this.api
+    );
+  }
+  normalizeAutoRefreshConfig(config) {
+    if (typeof config === "boolean") {
+      return { enabled: config, thresholdMinutes: 5 };
+    }
+    if (typeof config === "object" && config !== null) {
+      return {
+        enabled: config.enabled,
+        thresholdMinutes: config.thresholdMinutes ?? 5
+      };
+    }
+    return { enabled: true, thresholdMinutes: 5 };
+  }
+  /**
+   * Inyecta tokens desde storage externo (cookies/localStorage/etc)
+   */
+  setTokensFromExternal(accessToken, refreshToken, expiresAt, rememberMe = false) {
+    const tokens = {
+      accessToken,
+      refreshToken,
+      expiresAt,
+      rememberMe
+    };
+    this.tokenManager.setTokens(tokens);
+  }
+  /**
+   * Obtiene los tokens actuales
+   */
+  getTokens() {
+    return this.tokenManager.getTokens();
+  }
+  /**
+   * Verifica si el usuario está autenticado
+   */
+  isAuthenticated() {
+    return this.tokenManager.hasValidTokens();
+  }
+  /**
+   * Verifica si la sesión está por expirar
+   */
+  isSessionExpiringSoon(thresholdMinutes = 5) {
+    return this.tokenManager.isTokenExpiringSoon(thresholdMinutes);
+  }
+  /**
+   * Obtiene el tiempo restante hasta la expiración en milisegundos
+   */
+  getTimeUntilExpiry() {
+    return this.tokenManager.getTimeUntilExpiry();
+  }
+};
+export {
+  API,
+  AuthInterceptor,
+  AuthService,
+  CryptoService,
+  FalconHUBSDK,
+  TokenManager
+};
+//# sourceMappingURL=index.mjs.map