@calimero-network/mero-js 0.1.0

package/dist/index.mjs

@@ -0,0 +1,973 @@
+// src/http-client/signal-utils.ts
+function combineSignals(signals) {
+  const list = signals.filter(Boolean);
+  if (list.length === 0) return void 0;
+  const AbortSignalAny = AbortSignal;
+  if (typeof AbortSignalAny.any === "function") {
+    try {
+      return AbortSignalAny.any(list);
+    } catch {
+    }
+  }
+  const controller = new AbortController();
+  const onAbort = (evt) => {
+    controller.abort(evt.target.reason);
+    for (const s of list) s.removeEventListener("abort", onAbort);
+  };
+  for (const s of list) {
+    if (s.aborted) return AbortSignal.abort(s.reason);
+    s.addEventListener("abort", onAbort, { once: true });
+  }
+  return controller.signal;
+}
+function createTimeoutSignal(timeoutMs) {
+  if (typeof AbortSignal.timeout === "function") {
+    return AbortSignal.timeout(timeoutMs);
+  }
+  const controller = new AbortController();
+  setTimeout(() => {
+    controller.abort(new DOMException("Timeout", "TimeoutError"));
+  }, timeoutMs);
+  return controller.signal;
+}
+
+// src/http-client/web-client.ts
+var HTTPError = class extends Error {
+  constructor(status, statusText, url, headers, bodyText) {
+    super(`HTTP ${status} ${statusText}`);
+    this.status = status;
+    this.statusText = statusText;
+    this.url = url;
+    this.headers = headers;
+    this.bodyText = bodyText;
+    this.name = "HTTPError";
+  }
+  toJSON() {
+    return {
+      status: this.status,
+      statusText: this.statusText,
+      url: this.url,
+      headers: headersToRecord(this.headers),
+      bodyText: this.bodyText
+    };
+  }
+};
+function headersToRecord(headers) {
+  const record = {};
+  headers.forEach((value, key) => {
+    record[key] = value;
+  });
+  return record;
+}
+var WebHttpClient = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async get(path, init) {
+    return this.request(path, { ...init, method: "GET" });
+  }
+  async post(path, body, init) {
+    return this.request(path, {
+      ...init,
+      method: "POST",
+      body: body ? JSON.stringify(body) : void 0,
+      headers: {
+        "Content-Type": "application/json",
+        ...init?.headers
+      }
+    });
+  }
+  async put(path, body, init) {
+    return this.request(path, {
+      ...init,
+      method: "PUT",
+      body: body ? JSON.stringify(body) : void 0,
+      headers: {
+        "Content-Type": "application/json",
+        ...init?.headers
+      }
+    });
+  }
+  async delete(path, init) {
+    return this.request(path, { ...init, method: "DELETE" });
+  }
+  async patch(path, body, init) {
+    return this.request(path, {
+      ...init,
+      method: "PATCH",
+      body: body ? JSON.stringify(body) : void 0,
+      headers: {
+        "Content-Type": "application/json",
+        ...init?.headers
+      }
+    });
+  }
+  async head(path, init) {
+    const response = await this.makeRequest(path, {
+      ...init,
+      method: "HEAD",
+      parse: "response"
+    });
+    return {
+      headers: headersToRecord(response.headers),
+      status: response.status
+    };
+  }
+  async request(path, init) {
+    return this.makeRequest(path, init);
+  }
+  async makeRequest(path, init) {
+    const url = this.buildUrl(path);
+    const hasTauriInternals = typeof window !== "undefined" && "__TAURI_INTERNALS__" in window;
+    const hasTauri = typeof window !== "undefined" && "__TAURI__" in window;
+    const isTauri = hasTauriInternals || hasTauri || this.transport.credentials === "omit";
+    if (isTauri) {
+      const headers2 = await this.buildHeaders(init?.headers);
+      let headersObj2;
+      if (headers2 instanceof Headers) {
+        headersObj2 = {};
+        headers2.forEach((value, key) => {
+          headersObj2[key] = value;
+        });
+      } else {
+        headersObj2 = headers2;
+      }
+      const requestInit2 = {};
+      if (init?.method && init.method !== "GET") {
+        requestInit2.method = init.method;
+      }
+      if (headersObj2 && Object.keys(headersObj2).length > 0) {
+        requestInit2.headers = headersObj2;
+      }
+      if (init?.body !== void 0 && init.body !== null) {
+        requestInit2.body = init.body;
+      }
+      if (this.transport.credentials !== void 0) {
+        requestInit2.credentials = this.transport.credentials;
+      }
+      try {
+        const response = await globalThis.fetch(url, requestInit2);
+        if (!response.ok) {
+          const bodyText = await this.getBodyText(response);
+          throw new HTTPError(
+            response.status,
+            response.statusText,
+            url,
+            response.headers,
+            bodyText
+          );
+        }
+        return this.parseResponse(response, init?.parse);
+      } catch (error) {
+        if (error instanceof HTTPError) {
+          throw error;
+        }
+        throw new HTTPError(
+          0,
+          "Network Error",
+          url,
+          new Headers(),
+          error instanceof Error ? error.message : "Unknown error"
+        );
+      }
+    }
+    const signal = this.createAbortSignal(init);
+    const headers = await this.buildHeaders(init?.headers);
+    let headersObj;
+    if (headers instanceof Headers) {
+      headersObj = {};
+      headers.forEach((value, key) => {
+        headersObj[key] = value;
+      });
+    } else {
+      headersObj = headers;
+    }
+    const requestInit = {
+      method: init?.method || "GET",
+      headers: headersObj
+    };
+    if (init?.body !== void 0) {
+      requestInit.body = init.body;
+    }
+    if (signal) {
+      requestInit.signal = signal;
+    }
+    if (this.transport.credentials !== void 0) {
+      requestInit.credentials = this.transport.credentials;
+    }
+    if (init?.mode !== void 0) {
+      requestInit.mode = init.mode;
+    }
+    if (init?.cache !== void 0) {
+      requestInit.cache = init.cache;
+    }
+    if (init?.redirect !== void 0) {
+      requestInit.redirect = init.redirect;
+    }
+    if (init?.referrer !== void 0) {
+      requestInit.referrer = init.referrer;
+    }
+    if (init?.referrerPolicy !== void 0) {
+      requestInit.referrerPolicy = init.referrerPolicy;
+    }
+    if (init?.integrity !== void 0) {
+      requestInit.integrity = init.integrity;
+    }
+    if (init?.keepalive !== void 0) {
+      requestInit.keepalive = init.keepalive;
+    }
+    try {
+      const response = await this.transport.fetch(url, requestInit);
+      if (!response.ok) {
+        const bodyText = await this.getBodyText(response);
+        throw new HTTPError(
+          response.status,
+          response.statusText,
+          url,
+          response.headers,
+          bodyText
+        );
+      }
+      return this.parseResponse(response, init?.parse);
+    } catch (error) {
+      if (error instanceof HTTPError) {
+        throw error;
+      }
+      throw new HTTPError(
+        0,
+        "Network Error",
+        url,
+        new Headers(),
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+  }
+  buildUrl(path) {
+    if (path.startsWith("http://") || path.startsWith("https://")) {
+      return path;
+    }
+    const baseUrl = this.transport.baseUrl;
+    if (path.startsWith("/")) {
+      const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+      return `${base}${path}`;
+    } else {
+      const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+      return `${base}${path}`;
+    }
+  }
+  createAbortSignal(init) {
+    const isTauri = typeof window !== "undefined" && "__TAURI_INTERNALS__" in window;
+    if (isTauri) {
+      return void 0;
+    }
+    const signals = [];
+    if (this.transport.defaultAbortSignal) {
+      signals.push(this.transport.defaultAbortSignal);
+    }
+    if (init?.signal) {
+      signals.push(init.signal);
+    }
+    const timeoutMs = init?.timeoutMs || this.transport.timeoutMs;
+    if (timeoutMs) {
+      signals.push(createTimeoutSignal(timeoutMs));
+    }
+    return signals.length > 0 ? combineSignals(signals) : void 0;
+  }
+  async buildHeaders(initHeaders) {
+    const headers = {
+      ...this.transport.defaultHeaders
+    };
+    if (this.transport.getAuthToken) {
+      try {
+        const token = await this.transport.getAuthToken();
+        if (token && token.trim() !== "") {
+          headers.Authorization = `Bearer ${token}`;
+        }
+      } catch (error) {
+      }
+    }
+    if (initHeaders) {
+      if (initHeaders instanceof Headers) {
+        initHeaders.forEach((value, key) => {
+          headers[key] = value;
+        });
+      } else if (Array.isArray(initHeaders)) {
+        initHeaders.forEach(([key, value]) => {
+          headers[key] = value;
+        });
+      } else {
+        Object.assign(headers, initHeaders);
+      }
+    }
+    return headers;
+  }
+  async parseResponse(response, parse) {
+    switch (parse) {
+      case "text":
+        return await response.text();
+      case "blob":
+        return await response.blob();
+      case "arrayBuffer":
+        return await response.arrayBuffer();
+      case "response":
+        return response;
+      case "json":
+      default:
+        return await response.json();
+    }
+  }
+  async getBodyText(response) {
+    try {
+      const text = await response.text();
+      return text.length > 65536 ? text.slice(0, 65536) + "..." : text;
+    } catch {
+      return "";
+    }
+  }
+};
+
+// src/http-client/http-factory.ts
+function createHttpClient(transport) {
+  return new WebHttpClient(transport);
+}
+function createBrowserHttpClient(options) {
+  const transport = {
+    fetch: globalThis.fetch,
+    baseUrl: options.baseUrl,
+    getAuthToken: options.getAuthToken,
+    onTokenRefresh: options.onTokenRefresh,
+    defaultHeaders: options.defaultHeaders,
+    timeoutMs: options.timeoutMs,
+    credentials: options.credentials,
+    // No default credentials
+    defaultAbortSignal: options.defaultAbortSignal
+  };
+  return createHttpClient(transport);
+}
+function createNodeHttpClient(options) {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error(
+      "No fetch implementation available. Please provide a fetch implementation (e.g., undici.fetch) or use Node.js 18+ which has native fetch support."
+    );
+  }
+  const transport = {
+    fetch: fetchImpl,
+    baseUrl: options.baseUrl,
+    getAuthToken: options.getAuthToken,
+    onTokenRefresh: options.onTokenRefresh,
+    defaultHeaders: options.defaultHeaders,
+    timeoutMs: options.timeoutMs,
+    credentials: options.credentials,
+    // Node.js doesn't have default credentials
+    defaultAbortSignal: options.defaultAbortSignal
+  };
+  return createHttpClient(transport);
+}
+function createUniversalHttpClient(options) {
+  if (typeof window !== "undefined") {
+    return createBrowserHttpClient(options);
+  } else {
+    return createNodeHttpClient(options);
+  }
+}
+
+// src/http-client/retry.ts
+function defaultRetryCondition(error, attempt) {
+  if (attempt <= 0) return false;
+  const errorWithName = error;
+  const name = errorWithName?.name;
+  if (name === "TimeoutError") return true;
+  if (name === "AbortError") return false;
+  const errorWithStatus = error;
+  if ("status" in errorWithStatus && typeof errorWithStatus.status === "number") {
+    const status = errorWithStatus.status;
+    return status >= 500 || status === 429;
+  }
+  if (name === "TypeError") return true;
+  return false;
+}
+function calculateDelay(attempt) {
+  const baseDelayMs = 250;
+  const delay = baseDelayMs * Math.pow(2, attempt - 1);
+  const jitter = (Math.random() - 0.5) * 0.4 * delay;
+  return Math.max(0, delay + jitter);
+}
+async function withRetry(fn, options = {}) {
+  const { attempts = 3 } = options;
+  let lastError;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    try {
+      return await fn(attempt);
+    } catch (error) {
+      lastError = error;
+      if (!defaultRetryCondition(lastError, attempts - attempt)) {
+        throw lastError;
+      }
+      let delayMs = calculateDelay(attempt);
+      const errorWithHeaders = lastError;
+      const hdrs = errorWithHeaders.headers;
+      const retryAfter = hdrs?.get?.("Retry-After");
+      if (retryAfter) {
+        const seconds = parseInt(retryAfter, 10);
+        if (!isNaN(seconds)) {
+          delayMs = Math.max(delayMs, seconds * 1e3);
+        } else {
+          const date = new Date(retryAfter);
+          if (!isNaN(date.getTime())) {
+            const waitTime = Math.max(0, date.getTime() - Date.now());
+            delayMs = Math.max(delayMs, Math.min(waitTime, 6e4));
+          }
+        }
+      }
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  throw lastError || new Error("Retry failed without error");
+}
+function createRetryableMethod(method, retryOptions = {}) {
+  return async (...args) => {
+    return withRetry(() => method(...args), retryOptions);
+  };
+}
+
+// src/auth-api/auth-client.ts
+var AuthApiClient = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  // Health and Status Endpoints
+  async getHealth() {
+    const response = await this.httpClient.get("/auth/health");
+    if (!response.data) {
+      throw new Error("Health response data is null");
+    }
+    return response.data;
+  }
+  async getIdentity() {
+    const response = await this.httpClient.get(
+      "/admin/identity"
+    );
+    if (!response.data) {
+      throw new Error("Identity response data is null");
+    }
+    return response.data;
+  }
+  async getProviders() {
+    const response = await this.httpClient.get(
+      "/auth/providers"
+    );
+    if (!response.data) {
+      throw new Error("Providers response data is null");
+    }
+    return response.data;
+  }
+  // Authentication Endpoints
+  async getLoginPage() {
+    return this.httpClient.get("/auth/login", { parse: "text" });
+  }
+  async generateTokens(request) {
+    return this.httpClient.post("/auth/token", request);
+  }
+  async refreshToken(request) {
+    return this.httpClient.post("/auth/refresh", request);
+  }
+  async generateMockTokens(request) {
+    return this.httpClient.post("/auth/mock-token", request);
+  }
+  async getChallenge() {
+    return this.httpClient.get("/auth/challenge");
+  }
+  async validateToken(token) {
+    try {
+      const response = await this.validateTokenGet(token);
+      return {
+        valid: response.status === 200,
+        headers: response.headers,
+        status: response.status
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        headers: {},
+        status: 401
+      };
+    }
+  }
+  async validateTokenGet(token) {
+    const response = await this.httpClient.head("/auth/validate", {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    return {
+      status: response.status,
+      headers: response.headers
+    };
+  }
+  async isAuthed() {
+    return this.httpClient.get("/auth/is-authed");
+  }
+  // Token Management Endpoints
+  async revokeTokens(request) {
+    return this.httpClient.post("/admin/revoke", request);
+  }
+  // Key Management Endpoints
+  async listRootKeys() {
+    const response = await this.httpClient.get("/admin/keys");
+    if (!response.data) {
+      throw new Error("Root keys response data is null");
+    }
+    return response.data;
+  }
+  async createRootKey(request) {
+    return this.httpClient.post("/admin/keys", request);
+  }
+  async deleteRootKey(keyId) {
+    return this.httpClient.delete(`/admin/keys/${keyId}`);
+  }
+  // Client Management Endpoints
+  async listClientKeys() {
+    const response = await this.httpClient.get(
+      "/admin/keys/clients"
+    );
+    if (!response.data) {
+      throw new Error("Client keys response data is null");
+    }
+    return response.data;
+  }
+  async generateClientKey(request) {
+    return this.httpClient.post("/admin/client-key", request);
+  }
+  async deleteClientKey(keyId, clientId) {
+    return this.httpClient.delete(
+      `/admin/keys/${keyId}/clients/${clientId}`
+    );
+  }
+  // Permission Management Endpoints
+  async getKeyPermissions(keyId) {
+    return this.httpClient.get(
+      `/admin/keys/${keyId}/permissions`
+    );
+  }
+  async updateKeyPermissions(keyId, permissions) {
+    return this.httpClient.put(
+      `/admin/keys/${keyId}/permissions`,
+      { permissions }
+    );
+  }
+};
+
+// src/auth-api/auth-factory.ts
+var MockHttpClient = class {
+  async get() {
+    throw new Error(
+      "HTTP client not implemented - use createAuthApiClientFromHttpClient with a real HTTP client"
+    );
+  }
+  async post() {
+    throw new Error(
+      "HTTP client not implemented - use createAuthApiClientFromHttpClient with a real HTTP client"
+    );
+  }
+  async put() {
+    throw new Error(
+      "HTTP client not implemented - use createAuthApiClientFromHttpClient with a real HTTP client"
+    );
+  }
+  async delete() {
+    throw new Error(
+      "HTTP client not implemented - use createAuthApiClientFromHttpClient with a real HTTP client"
+    );
+  }
+  async patch() {
+    throw new Error(
+      "HTTP client not implemented - use createAuthApiClientFromHttpClient with a real HTTP client"
+    );
+  }
+  async head() {
+    throw new Error(
+      "HTTP client not implemented - use createAuthApiClientFromHttpClient with a real HTTP client"
+    );
+  }
+  async request() {
+    throw new Error(
+      "HTTP client not implemented - use createAuthApiClientFromHttpClient with a real HTTP client"
+    );
+  }
+};
+function createBrowserAuthApiClient(_config) {
+  const httpClient = new MockHttpClient();
+  return new AuthApiClient(httpClient);
+}
+function createNodeAuthApiClient(_config) {
+  const httpClient = new MockHttpClient();
+  return new AuthApiClient(httpClient);
+}
+function createAuthApiClient(_config) {
+  const httpClient = new MockHttpClient();
+  return new AuthApiClient(httpClient);
+}
+function createAuthApiClientFromHttpClient(httpClient, _config) {
+  return new AuthApiClient(httpClient);
+}
+
+// src/admin-api/admin-client.ts
+var AdminApiClient = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  // Health and Status Endpoints
+  async healthCheck() {
+    const response = await this.httpClient.get("/health");
+    if (!response.data) {
+      throw new Error("Health response data is null");
+    }
+    return response.data;
+  }
+  async isAuthed() {
+    return this.httpClient.get("/is-authed");
+  }
+  // Application Management Endpoints
+  async installApplication(request) {
+    return this.httpClient.post(
+      "/install-application",
+      request
+    );
+  }
+  async installDevApplication(request) {
+    return this.httpClient.post(
+      "/install-dev-application",
+      request
+    );
+  }
+  async uninstallApplication(appId) {
+    return this.httpClient.delete(
+      `/applications/${appId}`
+    );
+  }
+  async listApplications() {
+    return this.httpClient.get("/applications");
+  }
+  async getApplication(appId) {
+    return this.httpClient.get(
+      `/applications/${appId}`
+    );
+  }
+  // Context Management Endpoints
+  async createContext(request) {
+    return this.httpClient.post("/contexts", request);
+  }
+  async deleteContext(contextId) {
+    return this.httpClient.delete(
+      `/contexts/${contextId}`
+    );
+  }
+  async getContexts() {
+    return this.httpClient.get("/contexts");
+  }
+  async getContext(contextId) {
+    return this.httpClient.get(`/contexts/${contextId}`);
+  }
+  // Blob Management Endpoints
+  async uploadBlob(request) {
+    return this.httpClient.post("/blobs", request);
+  }
+  async deleteBlob(blobId) {
+    return this.httpClient.delete(`/blobs/${blobId}`);
+  }
+  async listBlobs() {
+    return this.httpClient.get("/blobs");
+  }
+  async getBlob(blobId) {
+    return this.httpClient.get(`/blobs/${blobId}`);
+  }
+  // Alias Management Endpoints
+  async createAlias(request) {
+    return this.httpClient.post("/alias", request);
+  }
+  async deleteAlias(aliasId) {
+    return this.httpClient.delete(`/alias/${aliasId}`);
+  }
+  async listAliases() {
+    return this.httpClient.get("/alias");
+  }
+  async getAlias(aliasId) {
+    return this.httpClient.get(`/alias/${aliasId}`);
+  }
+  // Network Management Endpoints
+  async getNetworkPeers() {
+    return this.httpClient.get("/network/peers");
+  }
+  async getNetworkStats() {
+    return this.httpClient.get("/network/stats");
+  }
+  async getNetworkConfig() {
+    return this.httpClient.get("/network/config");
+  }
+  async updateNetworkConfig(request) {
+    return this.httpClient.put(
+      "/network/config",
+      request
+    );
+  }
+  async getPeersCount() {
+    return this.httpClient.get("/network/peers/count");
+  }
+  // System Management Endpoints
+  async getSystemInfo() {
+    return this.httpClient.get("/system/info");
+  }
+  async getSystemLogs() {
+    return this.httpClient.get("/system/logs");
+  }
+  async getSystemMetrics() {
+    return this.httpClient.get("/system/metrics");
+  }
+  async restartSystem() {
+    return this.httpClient.post("/system/restart");
+  }
+  async shutdownSystem() {
+    return this.httpClient.post("/system/shutdown");
+  }
+};
+
+// src/admin-api/admin-factory.ts
+var MockHttpClient2 = class {
+  async get() {
+    throw new Error(
+      "HTTP client not implemented - use createAdminApiClientFromHttpClient with a real HTTP client"
+    );
+  }
+  async post() {
+    throw new Error(
+      "HTTP client not implemented - use createAdminApiClientFromHttpClient with a real HTTP client"
+    );
+  }
+  async put() {
+    throw new Error(
+      "HTTP client not implemented - use createAdminApiClientFromHttpClient with a real HTTP client"
+    );
+  }
+  async delete() {
+    throw new Error(
+      "HTTP client not implemented - use createAdminApiClientFromHttpClient with a real HTTP client"
+    );
+  }
+  async patch() {
+    throw new Error(
+      "HTTP client not implemented - use createAdminApiClientFromHttpClient with a real HTTP client"
+    );
+  }
+  async head() {
+    throw new Error(
+      "HTTP client not implemented - use createAdminApiClientFromHttpClient with a real HTTP client"
+    );
+  }
+  async request() {
+    throw new Error(
+      "HTTP client not implemented - use createAdminApiClientFromHttpClient with a real HTTP client"
+    );
+  }
+};
+function createBrowserAdminApiClient(_config) {
+  const httpClient = new MockHttpClient2();
+  return new AdminApiClient(httpClient);
+}
+function createNodeAdminApiClient(_config) {
+  const httpClient = new MockHttpClient2();
+  return new AdminApiClient(httpClient);
+}
+function createAdminApiClient(_config) {
+  const httpClient = new MockHttpClient2();
+  return new AdminApiClient(httpClient);
+}
+function createAdminApiClientFromHttpClient(httpClient, _config) {
+  return new AdminApiClient(httpClient);
+}
+
+// src/mero-js.ts
+var MeroJs = class {
+  constructor(config) {
+    this.tokenData = null;
+    this.refreshPromise = null;
+    this.config = {
+      timeoutMs: 1e4,
+      ...config
+    };
+    const isTauri = typeof window !== "undefined" && "__TAURI_INTERNALS__" in window;
+    this.httpClient = createBrowserHttpClient({
+      baseUrl: this.config.baseUrl,
+      getAuthToken: async () => {
+        const token = await this.getValidToken();
+        return token?.access_token || "";
+      },
+      timeoutMs: this.config.timeoutMs,
+      credentials: this.config.requestCredentials ?? (isTauri ? "omit" : void 0)
+    });
+    this.authClient = createAuthApiClientFromHttpClient(this.httpClient, {
+      baseUrl: this.config.baseUrl,
+      getAuthToken: async () => {
+        const token = await this.getValidToken();
+        return token?.access_token || "";
+      },
+      timeoutMs: this.config.timeoutMs
+    });
+    this.adminClient = createAdminApiClientFromHttpClient(this.httpClient, {
+      baseUrl: this.config.baseUrl,
+      getAuthToken: async () => {
+        const token = await this.getValidToken();
+        return token?.access_token || "";
+      },
+      timeoutMs: this.config.timeoutMs
+    });
+  }
+  /**
+   * Get the Auth API client
+   */
+  get auth() {
+    return this.authClient;
+  }
+  /**
+   * Get the Admin API client
+   */
+  get admin() {
+    return this.adminClient;
+  }
+  /**
+   * Authenticate with the provided credentials
+   * This will create the root key on first use
+   */
+  async authenticate(credentials) {
+    const creds = credentials || this.config.credentials;
+    if (!creds) {
+      throw new Error("No credentials provided for authentication");
+    }
+    try {
+      const requestBody = {
+        auth_method: "user_password",
+        public_key: creds.username,
+        client_name: "mero-js-sdk",
+        permissions: ["admin"],
+        timestamp: Math.floor(Date.now() / 1e3),
+        provider_data: {
+          username: creds.username,
+          password: creds.password
+        }
+      };
+      const response = await this.authClient.generateTokens(requestBody);
+      this.tokenData = {
+        access_token: response.data.access_token,
+        refresh_token: response.data.refresh_token,
+        expires_at: Date.now() + 24 * 60 * 60 * 1e3
+        // Default to 24 hours
+      };
+      return this.tokenData;
+    } catch (error) {
+      throw new Error(
+        `Authentication failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Get a valid token, refreshing if necessary
+   */
+  async getValidToken() {
+    if (!this.tokenData) {
+      return null;
+    }
+    const bufferTime = 5 * 60 * 1e3;
+    if (Date.now() >= this.tokenData.expires_at - bufferTime) {
+      return await this.refreshToken();
+    }
+    return this.tokenData;
+  }
+  /**
+   * Refresh the access token using the refresh token
+   */
+  async refreshToken() {
+    if (!this.tokenData?.refresh_token) {
+      throw new Error("No refresh token available");
+    }
+    if (this.refreshPromise) {
+      return this.refreshPromise;
+    }
+    this.refreshPromise = this.performTokenRefresh();
+    try {
+      const newToken = await this.refreshPromise;
+      return newToken;
+    } finally {
+      this.refreshPromise = null;
+    }
+  }
+  /**
+   * Perform the actual token refresh
+   */
+  async performTokenRefresh() {
+    if (!this.tokenData?.refresh_token) {
+      throw new Error("No refresh token available");
+    }
+    try {
+      const response = await this.authClient.refreshToken({
+        access_token: this.tokenData.access_token,
+        refresh_token: this.tokenData.refresh_token
+      });
+      this.tokenData = {
+        access_token: response.data.access_token,
+        refresh_token: response.data.refresh_token,
+        expires_at: Date.now() + 24 * 60 * 60 * 1e3
+        // Default to 24 hours
+      };
+      return this.tokenData;
+    } catch (error) {
+      this.clearToken();
+      throw new Error(
+        `Token refresh failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Clear the current token
+   */
+  clearToken() {
+    this.tokenData = null;
+  }
+  /**
+   * Check if the SDK is authenticated
+   */
+  isAuthenticated() {
+    return this.tokenData !== null;
+  }
+  /**
+   * Get the current token data (for debugging)
+   */
+  getTokenData() {
+    return this.tokenData;
+  }
+};
+function createMeroJs(config) {
+  return new MeroJs(config);
+}
+export {
+  AdminApiClient,
+  AuthApiClient,
+  HTTPError,
+  MeroJs,
+  WebHttpClient,
+  combineSignals,
+  createAdminApiClient,
+  createAdminApiClientFromHttpClient,
+  createAuthApiClient,
+  createAuthApiClientFromHttpClient,
+  createBrowserAdminApiClient,
+  createBrowserAuthApiClient,
+  createBrowserHttpClient,
+  createHttpClient,
+  createMeroJs,
+  createNodeAdminApiClient,
+  createNodeAuthApiClient,
+  createNodeHttpClient,
+  createRetryableMethod,
+  createTimeoutSignal,
+  createUniversalHttpClient,
+  withRetry
+};
+//# sourceMappingURL=index.mjs.map