@dinoconfig/js-sdk 1.0.0

package/index.js

@@ -0,0 +1,883 @@
+class w {
+  /**
+   * Creates a new HttpClient instance.
+   * 
+   * @param {string} baseUrl - The base URL of the DinoConfig API
+   * @param {number} [timeout=10000] - Default request timeout in milliseconds
+   * 
+   * @example
+   * ```typescript
+   * const client = new HttpClient('https://api.dinoconfig.com', 15000);
+   * ```
+   */
+  constructor(e, t = 1e4) {
+    this.baseUrl = e.replace(/\/$/, ""), this.defaultTimeout = t;
+  }
+  /**
+   * Configures authorization by exchanging the API key for an access token.
+   * 
+   * This method:
+   * 1. Extracts the API key from the provided headers
+   * 2. Exchanges it for a JWT access token
+   * 3. Configures the Authorization header for subsequent requests
+   * 
+   * @async
+   * @method configureAuthorizationHeader
+   * @param {Record<string, string>} headers - Headers containing the X-API-Key
+   * @returns {Promise<void>}
+   * @throws {Error} If token exchange fails
+   * 
+   * @example
+   * ```typescript
+   * await client.configureAuthorizationHeader({
+   *   'X-API-Key': 'dino_your-api-key-here'
+   * });
+   * // Client is now authenticated
+   * ```
+   */
+  async configureAuthorizationHeader(e) {
+    const t = e["X-API-Key"], s = await this.exchangeApiKeyForToken(t);
+    this.defaultHeaders = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${s}`,
+      ...e
+    };
+  }
+  /**
+   * Exchanges an API key for a JWT access token.
+   * 
+   * Makes a POST request to the token exchange endpoint with the API key
+   * and returns the access token from the response.
+   * 
+   * @async
+   * @private
+   * @method exchangeApiKeyForToken
+   * @param {string} apiKey - The API key to exchange
+   * @returns {Promise<string>} The JWT access token
+   * @throws {Error} If the exchange fails or the API key is invalid
+   * 
+   * @remarks
+   * The API key is sent via HTTPS, which encrypts it in transit.
+   * The server validates the key and returns a short-lived access token.
+   */
+  async exchangeApiKeyForToken(e) {
+    try {
+      const t = await fetch(`${this.baseUrl}/api/auth/sdk-token/exchange`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": e
+        },
+        credentials: "include"
+      });
+      if (!t.ok) {
+        const r = await t.text();
+        throw new Error(`Failed to exchange API key for token: ${t.status} ${r}`);
+      }
+      return (await t.json()).access_token;
+    } catch (t) {
+      const s = t instanceof Error ? t.message : "Unknown error";
+      throw new Error(`Failed to authenticate with API key: ${s}`);
+    }
+  }
+  /**
+   * Makes an HTTP request to the API.
+   * 
+   * Handles:
+   * - Request formatting and headers
+   * - Timeout via AbortController
+   * - Response parsing
+   * - Error handling
+   * - Retry logic with exponential backoff
+   * 
+   * @async
+   * @private
+   * @method request
+   * @typeParam T - The expected response data type
+   * @param {string} method - HTTP method (GET, POST, PUT, PATCH, DELETE)
+   * @param {string} endpoint - API endpoint path (e.g., '/api/configs')
+   * @param {any} [data] - Request body data (for POST, PUT, PATCH)
+   * @param {RequestOptions} [options={}] - Request customization options
+   * @returns {Promise<ApiResponse<T>>} The API response
+   * @throws {ApiError} If the request fails after all retries
+   */
+  async request(e, t, s, r = {}) {
+    const a = `${this.baseUrl}${t}`, i = r.timeout || this.defaultTimeout, c = r.retries || 0;
+    let h = null;
+    for (let l = 0; l <= c; l++)
+      try {
+        const n = new AbortController(), o = setTimeout(() => n.abort(), i), d = {
+          method: e,
+          headers: this.defaultHeaders,
+          signal: n.signal
+        };
+        s && (e === "POST" || e === "PUT" || e === "PATCH") && (d.body = JSON.stringify(s));
+        const f = await fetch(a, d);
+        clearTimeout(o);
+        const p = await f.json();
+        if (!f.ok)
+          throw {
+            message: p.message || f.statusText,
+            status: f.status,
+            code: p.code
+          };
+        return {
+          data: p,
+          success: !0
+        };
+      } catch (n) {
+        if (h = n, n instanceof Error && "status" in n) {
+          const o = n;
+          if (o.status >= 400 && o.status < 500)
+            throw n;
+        }
+        if (l === c)
+          throw n;
+        await new Promise((o) => setTimeout(o, Math.pow(2, l) * 1e3));
+      }
+    throw h || new Error("Request failed after all retries");
+  }
+  /**
+   * Makes a GET request to the specified endpoint.
+   * 
+   * @async
+   * @method get
+   * @typeParam T - The expected response data type
+   * @param {string} endpoint - The API endpoint path
+   * @param {RequestOptions} [options] - Optional request configuration
+   * @returns {Promise<ApiResponse<T>>} The API response
+   * 
+   * @example
+   * ```typescript
+   * const response = await client.get<Config>('/api/configs/123');
+   * console.log(response.data.name);
+   * ```
+   */
+  async get(e, t) {
+    return this.request("GET", e, void 0, t);
+  }
+  /**
+   * Makes a POST request to the specified endpoint.
+   * 
+   * @async
+   * @method post
+   * @typeParam T - The expected response data type
+   * @param {string} endpoint - The API endpoint path
+   * @param {any} [data] - The request body data
+   * @param {RequestOptions} [options] - Optional request configuration
+   * @returns {Promise<ApiResponse<T>>} The API response
+   * 
+   * @example
+   * ```typescript
+   * const response = await client.post<Config>('/api/configs', {
+   *   name: 'NewConfig',
+   *   formData: { key: 'value' }
+   * });
+   * ```
+   */
+  async post(e, t, s) {
+    return this.request("POST", e, t, s);
+  }
+  /**
+   * Makes a PUT request to the specified endpoint.
+   * 
+   * @async
+   * @method put
+   * @typeParam T - The expected response data type
+   * @param {string} endpoint - The API endpoint path
+   * @param {any} [data] - The request body data
+   * @param {RequestOptions} [options] - Optional request configuration
+   * @returns {Promise<ApiResponse<T>>} The API response
+   * 
+   * @example
+   * ```typescript
+   * const response = await client.put<Config>('/api/configs/123', {
+   *   name: 'UpdatedConfig'
+   * });
+   * ```
+   */
+  async put(e, t, s) {
+    return this.request("PUT", e, t, s);
+  }
+  /**
+   * Makes a PATCH request to the specified endpoint.
+   * 
+   * @async
+   * @method patch
+   * @typeParam T - The expected response data type
+   * @param {string} endpoint - The API endpoint path
+   * @param {any} [data] - The request body data (partial update)
+   * @param {RequestOptions} [options] - Optional request configuration
+   * @returns {Promise<ApiResponse<T>>} The API response
+   * 
+   * @example
+   * ```typescript
+   * const response = await client.patch<Config>('/api/configs/123', {
+   *   formData: { updatedKey: 'newValue' }
+   * });
+   * ```
+   */
+  async patch(e, t, s) {
+    return this.request("PATCH", e, t, s);
+  }
+  /**
+   * Makes a DELETE request to the specified endpoint.
+   * 
+   * @async
+   * @method delete
+   * @typeParam T - The expected response data type
+   * @param {string} endpoint - The API endpoint path
+   * @param {RequestOptions} [options] - Optional request configuration
+   * @returns {Promise<ApiResponse<T>>} The API response
+   * 
+   * @example
+   * ```typescript
+   * const response = await client.delete('/api/configs/123');
+   * ```
+   */
+  async delete(e, t) {
+    return this.request("DELETE", e, void 0, t);
+  }
+  /**
+   * Updates the authorization token.
+   * 
+   * Use this method if you need to manually update the token
+   * (e.g., after refreshing it externally).
+   * 
+   * @method setToken
+   * @param {string} token - The new JWT access token
+   * 
+   * @example
+   * ```typescript
+   * client.setToken('new-jwt-token');
+   * ```
+   */
+  setToken(e) {
+    this.defaultHeaders.Authorization = `Bearer ${e}`;
+  }
+  /**
+   * Sets a custom header for all subsequent requests.
+   * 
+   * @method setHeader
+   * @param {string} key - The header name
+   * @param {string} value - The header value
+   * 
+   * @example
+   * ```typescript
+   * client.setHeader('X-Custom-Header', 'custom-value');
+   * ```
+   */
+  setHeader(e, t) {
+    this.defaultHeaders[e] = t;
+  }
+  /**
+   * Removes a custom header from subsequent requests.
+   * 
+   * @method removeHeader
+   * @param {string} key - The header name to remove
+   * 
+   * @example
+   * ```typescript
+   * client.removeHeader('X-Custom-Header');
+   * ```
+   */
+  removeHeader(e) {
+    delete this.defaultHeaders[e];
+  }
+}
+const y = "/api/sdk/brands";
+class C {
+  constructor(e, t) {
+    this.httpClient = e, this.cacheManager = t;
+  }
+  async get(e, t, s) {
+    const { brand: r, config: a, requestOptions: i } = this.parseConfigArgs(
+      e,
+      t,
+      s
+    ), c = `config:${r}:${a}`, h = this.cacheManager && i?.cache !== !1 && !i?.forceRefresh;
+    if (h) {
+      const o = await this.cacheManager.get(c);
+      if (o !== null)
+        return o;
+    }
+    const l = await this.httpClient.get(
+      this.buildConfigUrl(r, a),
+      i
+    ), n = {
+      ...l,
+      data: this.transformConfigResponse(l.data)
+    };
+    return h && l.success && await this.cacheManager.set(c, n, { ttl: i?.ttl }), n;
+  }
+  async getValue(e, t, s, r) {
+    const { brand: a, config: i, key: c, requestOptions: h } = this.parseValueArgs(
+      e,
+      t,
+      s,
+      r
+    ), l = `config:${a}:${i}:${c}`, n = this.cacheManager && h?.cache !== !1 && !h?.forceRefresh;
+    if (n) {
+      const d = await this.cacheManager.get(l);
+      if (d !== null)
+        return d;
+    }
+    const o = await this.httpClient.get(
+      this.buildValueUrl(a, i, c),
+      h
+    );
+    return n && o.success && await this.cacheManager.set(l, o, { ttl: h?.ttl }), o;
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private helpers
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Parses arguments for the get() method.
+   */
+  parseConfigArgs(e, t, s) {
+    if (typeof t == "string")
+      return {
+        brand: e,
+        config: t,
+        requestOptions: s
+      };
+    const r = this.parsePath(e, 2);
+    return {
+      brand: r[0],
+      config: r[1],
+      requestOptions: t
+    };
+  }
+  /**
+   * Parses arguments for the getValue() method.
+   */
+  parseValueArgs(e, t, s, r) {
+    if (typeof t == "string")
+      return {
+        brand: e,
+        config: t,
+        key: s,
+        requestOptions: r
+      };
+    const a = this.parsePath(e, 3);
+    return {
+      brand: a[0],
+      config: a[1],
+      key: a[2],
+      requestOptions: t
+    };
+  }
+  /**
+   * Parses a dot-notation path into components.
+   */
+  parsePath(e, t) {
+    const s = e.split(".");
+    if (s.length !== t) {
+      const r = t === 2 ? "brandName.configName" : "brandName.configName.keyName";
+      throw new Error(`Invalid path format "${e}". Expected "${r}"`);
+    }
+    return s;
+  }
+  /**
+   * Builds the URL for fetching an entire config.
+   */
+  buildConfigUrl(e, t) {
+    return `${y}/${this.encode(e)}/configs/${this.encode(t)}`;
+  }
+  /**
+   * Builds the URL for fetching a single value.
+   */
+  buildValueUrl(e, t, s) {
+    return `${y}/${this.encode(e)}/configs/${this.encode(t)}/${this.encode(s)}`;
+  }
+  /**
+   * URL-encodes a path segment.
+   */
+  encode(e) {
+    return encodeURIComponent(e);
+  }
+  /**
+   * Transforms the backend response to the public ConfigData shape.
+   */
+  transformConfigResponse(e) {
+    return {
+      name: e.name,
+      description: e.description,
+      values: e.formData,
+      version: e.version,
+      keys: e.keys,
+      createdAt: e.createdAt,
+      updatedAt: e.updatedAt
+    };
+  }
+}
+const g = "/api/sdk";
+class x {
+  constructor(e) {
+    this.httpClient = e;
+  }
+  /**
+   * Lists all brands accessible by the current API key.
+   *
+   * @example
+   * ```typescript
+   * const response = await dinoconfig.discovery.listBrands();
+   * response.data.forEach(brand => {
+   *   console.log(`${brand.name}: ${brand.configCount} configs`);
+   * });
+   * ```
+   */
+  async listBrands(e) {
+    const t = await this.httpClient.get(
+      `${g}/brands`,
+      e
+    );
+    return this.extractData(t, t.data.brands);
+  }
+  /**
+   * Lists all configurations for a specific brand.
+   *
+   * @example
+   * ```typescript
+   * const response = await dinoconfig.discovery.listConfigs('MyBrand');
+   * response.data.forEach(config => {
+   *   console.log(`${config.name}: ${config.keys.length} keys`);
+   * });
+   * ```
+   */
+  async listConfigs(e, t) {
+    const s = await this.httpClient.get(
+      this.buildBrandUrl(e, "/configs"),
+      t
+    );
+    return this.extractData(s, s.data.configs);
+  }
+  /**
+   * Gets the schema/structure for a specific configuration.
+   *
+   * @example
+   * ```typescript
+   * const response = await dinoconfig.discovery.getSchema('MyBrand', 'FeatureFlags');
+   * Object.entries(response.data.fields).forEach(([name, field]) => {
+   *   console.log(`${name}: ${field.type}`);
+   * });
+   * ```
+   */
+  async getSchema(e, t, s) {
+    return this.httpClient.get(
+      this.buildConfigUrl(e, t, "/schema"),
+      s
+    );
+  }
+  /**
+   * Performs full introspection, returning all brands, configs, and keys.
+   *
+   * @example
+   * ```typescript
+   * const response = await dinoconfig.discovery.introspect();
+   * response.data.brands.forEach(brand => {
+   *   console.log(`Brand: ${brand.name}`);
+   *   brand.configs.forEach(config => {
+   *     console.log(`  Config: ${config.name} (${config.keys.length} keys)`);
+   *   });
+   * });
+   * ```
+   */
+  async introspect(e) {
+    return this.httpClient.get(`${g}/introspect`, e);
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private helpers
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Builds URL path for brand-level endpoints.
+   */
+  buildBrandUrl(e, t = "") {
+    return `${g}/brands/${this.encode(e)}${t}`;
+  }
+  /**
+   * Builds URL path for config-level endpoints.
+   */
+  buildConfigUrl(e, t, s = "") {
+    return `${g}/brands/${this.encode(e)}/configs/${this.encode(t)}${s}`;
+  }
+  /**
+   * URL-encodes a path segment.
+   */
+  encode(e) {
+    return encodeURIComponent(e);
+  }
+  /**
+   * Extracts and transforms response data.
+   */
+  extractData(e, t) {
+    return {
+      ...e,
+      data: t
+    };
+  }
+}
+class m {
+  constructor(e, t) {
+    this.ttl = e, this.maxSize = t, this.cache = /* @__PURE__ */ new Map(), this.hits = 0, this.misses = 0;
+  }
+  /**
+   * Get a value from the cache.
+   * 
+   * @param {string} key - Cache key
+   * @returns {T | null} Cached value or null if not found/expired
+   */
+  get(e) {
+    const t = this.cache.get(e);
+    return t ? this.isExpired(t) ? (this.cache.delete(e), this.misses++, null) : (this.hits++, t.value) : (this.misses++, null);
+  }
+  /**
+   * Set a value in the cache.
+   * 
+   * @param {string} key - Cache key
+   * @param {T} value - Value to cache
+   * @param {CacheOptions} options - Optional cache options
+   */
+  set(e, t, s) {
+    const r = s?.ttl ?? this.ttl, a = {
+      value: t,
+      timestamp: Date.now(),
+      expiresAt: Date.now() + r
+    };
+    this.cache.size >= this.maxSize && !this.cache.has(e) && this.evictOldest(), this.cache.set(e, a);
+  }
+  /**
+   * Delete a value from the cache.
+   * 
+   * @param {string} key - Cache key
+   */
+  delete(e) {
+    this.cache.delete(e);
+  }
+  /**
+   * Clear all entries from the cache.
+   */
+  clear() {
+    this.cache.clear(), this.hits = 0, this.misses = 0;
+  }
+  /**
+   * Invalidate entries matching a pattern.
+   * 
+   * @param {string} pattern - Regex pattern to match keys
+   */
+  invalidate(e) {
+    const t = new RegExp(e);
+    for (const s of this.cache.keys())
+      t.test(s) && this.cache.delete(s);
+  }
+  /**
+   * Check if an entry exists and is not expired.
+   * 
+   * @param {string} key - Cache key
+   * @returns {boolean} True if entry exists and is valid
+   */
+  has(e) {
+    const t = this.cache.get(e);
+    return t ? this.isExpired(t) ? (this.cache.delete(e), !1) : !0 : !1;
+  }
+  /**
+   * Get cache statistics.
+   * 
+   * @returns {CacheStats} Cache statistics
+   */
+  getStats() {
+    const e = this.hits + this.misses;
+    return {
+      hits: this.hits,
+      misses: this.misses,
+      size: this.cache.size,
+      hitRate: e > 0 ? this.hits / e : 0
+    };
+  }
+  /**
+   * Check if an entry is expired.
+   * 
+   * @private
+   * @param {CacheEntry} entry - Cache entry
+   * @returns {boolean} True if expired
+   */
+  isExpired(e) {
+    return Date.now() > e.expiresAt;
+  }
+  /**
+   * Evict the oldest entry from the cache.
+   * Uses LRU-like strategy based on expiration time.
+   * 
+   * @private
+   */
+  evictOldest() {
+    let e = null, t = 1 / 0;
+    for (const [s, r] of this.cache.entries())
+      r.expiresAt < t && (t = r.expiresAt, e = s);
+    e && this.cache.delete(e);
+  }
+}
+class A {
+  constructor() {
+    if (typeof window > "u" || !window.localStorage)
+      throw new Error("localStorage is not available in this environment");
+    this.storage = window.localStorage;
+  }
+  getItem(e) {
+    try {
+      return this.storage.getItem(e);
+    } catch {
+      return null;
+    }
+  }
+  setItem(e, t) {
+    try {
+      this.storage.setItem(e, t);
+    } catch {
+    }
+  }
+  removeItem(e) {
+    try {
+      this.storage.removeItem(e);
+    } catch {
+    }
+  }
+  clear() {
+    try {
+      const e = Object.keys(this.storage);
+      for (const t of e)
+        t.startsWith("dinoconfig:") && this.storage.removeItem(t);
+    } catch {
+    }
+  }
+}
+class b {
+  constructor(e) {
+    if (this.prefix = "dinoconfig:", e === "localStorage")
+      this.adapter = new A();
+    else
+      throw new Error("IndexedDB storage is not yet implemented");
+  }
+  /**
+   * Get a value from storage cache.
+   * 
+   * @param {string} key - Cache key
+   * @returns {Promise<T | null>} Cached value or null if not found/expired
+   */
+  async get(e) {
+    try {
+      const t = this.adapter.getItem(this.prefix + e);
+      if (!t)
+        return null;
+      const s = JSON.parse(t);
+      return this.isExpired(s) ? (this.adapter.removeItem(this.prefix + e), null) : s.value;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Set a value in storage cache.
+   * 
+   * @param {string} key - Cache key
+   * @param {T} value - Value to cache
+   * @param {CacheOptions} options - Optional cache options
+   */
+  async set(e, t, s) {
+    try {
+      const r = s?.ttl ?? 3e5, a = {
+        value: t,
+        timestamp: Date.now(),
+        expiresAt: Date.now() + r
+      };
+      this.adapter.setItem(this.prefix + e, JSON.stringify(a));
+    } catch {
+    }
+  }
+  /**
+   * Delete a value from storage cache.
+   * 
+   * @param {string} key - Cache key
+   */
+  async delete(e) {
+    try {
+      this.adapter.removeItem(this.prefix + e);
+    } catch {
+    }
+  }
+  /**
+   * Clear all entries from storage cache.
+   */
+  async clear() {
+    try {
+      this.adapter.clear();
+    } catch {
+    }
+  }
+  /**
+   * Invalidate entries matching a pattern.
+   * 
+   * @param {string} pattern - Regex pattern to match keys
+   */
+  async invalidate(e) {
+    try {
+      const t = new RegExp(e), r = this.adapter.storage;
+      if (!r)
+        return;
+      const a = [];
+      for (let i = 0; i < r.length; i++) {
+        const c = r.key(i);
+        if (c && c.startsWith(this.prefix)) {
+          const h = c.substring(this.prefix.length);
+          t.test(h) && a.push(c);
+        }
+      }
+      for (const i of a)
+        this.adapter.removeItem(i);
+    } catch {
+    }
+  }
+  /**
+   * Check if an entry is expired.
+   * 
+   * @private
+   * @param {CacheEntry} entry - Cache entry
+   * @returns {boolean} True if expired
+   */
+  isExpired(e) {
+    return Date.now() > e.expiresAt;
+  }
+}
+class $ {
+  constructor(e) {
+    if (this.config = e, !e.enabled) {
+      this.memoryCache = new m(0, 0);
+      return;
+    }
+    if (this.memoryCache = new m(
+      e.ttl,
+      e.maxSize
+    ), e.storage && e.storage !== "memory")
+      try {
+        this.storageCache = new b(e.storage);
+      } catch {
+        this.storageCache = void 0;
+      }
+  }
+  /**
+   * Get a value from cache.
+   * Checks L1 (memory) first, then L2 (storage) if available.
+   * 
+   * @param {string} key - Cache key
+   * @returns {Promise<T | null>} Cached value or null if not found
+   */
+  async get(e) {
+    if (!this.config.enabled)
+      return null;
+    const t = this.memoryCache.get(e);
+    if (t !== null)
+      return t;
+    if (this.storageCache) {
+      const s = await this.storageCache.get(e);
+      if (s !== null)
+        return this.memoryCache.set(e, s), s;
+    }
+    return null;
+  }
+  /**
+   * Set a value in cache.
+   * Writes to both L1 (memory) and L2 (storage) if available.
+   * 
+   * @param {string} key - Cache key
+   * @param {T} value - Value to cache
+   * @param {CacheOptions} options - Optional cache options
+   */
+  async set(e, t, s) {
+    this.config.enabled && (this.memoryCache.set(e, t, s), this.storageCache && await this.storageCache.set(e, t, s));
+  }
+  /**
+   * Delete a value from cache.
+   * Removes from both L1 and L2.
+   * 
+   * @param {string} key - Cache key
+   */
+  async delete(e) {
+    this.memoryCache.delete(e), this.storageCache && await this.storageCache.delete(e);
+  }
+  /**
+   * Clear all cache entries.
+   */
+  async clear() {
+    this.memoryCache.clear(), this.storageCache && await this.storageCache.clear();
+  }
+  /**
+   * Invalidate entries matching a pattern.
+   * 
+   * @param {string} pattern - Regex pattern to match keys
+   */
+  async invalidate(e) {
+    if (!e) {
+      await this.clear();
+      return;
+    }
+    this.memoryCache.invalidate(e), this.storageCache && await this.storageCache.invalidate(e);
+  }
+  /**
+   * Check if a key exists in cache.
+   * 
+   * @param {string} key - Cache key
+   * @returns {boolean} True if key exists and is not expired
+   */
+  has(e) {
+    return this.config.enabled ? this.memoryCache.has(e) : !1;
+  }
+  /**
+   * Get cache statistics.
+   * 
+   * @returns {CacheStats} Cache statistics
+   */
+  getStats() {
+    return this.memoryCache.getStats();
+  }
+  /**
+   * Prefetch a value into cache.
+   * This is a convenience method for warming the cache.
+   * 
+   * @param {string} key - Cache key
+   * @param {() => Promise<T>} fetcher - Function to fetch the value if not cached
+   */
+  async prefetch(e, t) {
+    const s = await this.get(e);
+    if (s !== null)
+      return s;
+    const r = await t();
+    return await this.set(e, r), r;
+  }
+}
+async function I(u) {
+  const {
+    apiKey: e,
+    baseUrl: t = "http://localhost:3000",
+    timeout: s = 1e4,
+    cache: r
+  } = u, a = new w(t, s);
+  await a.configureAuthorizationHeader({
+    "X-API-Key": e
+  });
+  const i = new $({
+    enabled: r?.enabled ?? !1,
+    ttl: r?.ttl ?? 6e4,
+    maxSize: r?.maxSize ?? 1e3,
+    storage: r?.storage,
+    staleWhileRevalidate: r?.staleWhileRevalidate ?? !1
+  });
+  return {
+    configs: new C(a, i),
+    discovery: new x(a),
+    cache: i
+  };
+}
+export {
+  C as ConfigAPI,
+  x as DiscoveryAPI,
+  I as dinoconfigApi
+};