@dinoconfig/cli 0.0.0

package/codegen-DZxM8r9k.js

@@ -0,0 +1,1622 @@
+import { b as T, C as v, a as j, D as A, c as z } from "./constants-Dvwyqn-J.js";
+import * as f from "fs";
+import * as p from "path";
+class R {
+  /**
+   * 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 n = await t.text();
+        throw new Error(`Failed to exchange API key for token: ${t.status} ${n}`);
+      }
+      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, n = {}) {
+    const a = `${this.baseUrl}${t}`, r = n.timeout || this.defaultTimeout, o = n.retries || 0;
+    let l = null;
+    for (let c = 0; c <= o; c++)
+      try {
+        const u = new AbortController(), h = setTimeout(() => u.abort(), r), d = {
+          method: e,
+          headers: this.defaultHeaders,
+          signal: u.signal
+        };
+        s && (e === "POST" || e === "PUT" || e === "PATCH") && (d.body = JSON.stringify(s));
+        const m = await fetch(a, d);
+        clearTimeout(h);
+        const y = await m.json();
+        if (!m.ok)
+          throw {
+            message: y.message || m.statusText,
+            status: m.status,
+            code: y.code
+          };
+        return {
+          data: y,
+          success: !0
+        };
+      } catch (u) {
+        if (l = u, u instanceof Error && "status" in u) {
+          const h = u;
+          if (h.status >= 400 && h.status < 500)
+            throw u;
+        }
+        if (c === o)
+          throw u;
+        await new Promise((h) => setTimeout(h, Math.pow(2, c) * 1e3));
+      }
+    throw l || 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 I = "/api/sdk/brands";
+class M {
+  constructor(e, t) {
+    this.httpClient = e, this.cacheManager = t;
+  }
+  async get(e, t, s) {
+    const { brand: n, config: a, requestOptions: r } = this.parseConfigArgs(
+      e,
+      t,
+      s
+    ), o = `config:${n}:${a}`, l = this.cacheManager && r?.cache !== !1 && !r?.forceRefresh;
+    if (l) {
+      const h = await this.cacheManager.get(o);
+      if (h !== null)
+        return h;
+    }
+    const c = await this.httpClient.get(
+      this.buildConfigUrl(n, a),
+      r
+    ), u = {
+      ...c,
+      data: this.transformConfigResponse(c.data)
+    };
+    return l && c.success && await this.cacheManager.set(o, u, { ttl: r?.ttl }), u;
+  }
+  async getValue(e, t, s, n) {
+    const { brand: a, config: r, key: o, requestOptions: l } = this.parseValueArgs(
+      e,
+      t,
+      s,
+      n
+    ), c = `config:${a}:${r}:${o}`, u = this.cacheManager && l?.cache !== !1 && !l?.forceRefresh;
+    if (u) {
+      const d = await this.cacheManager.get(c);
+      if (d !== null)
+        return d;
+    }
+    const h = await this.httpClient.get(
+      this.buildValueUrl(a, r, o),
+      l
+    );
+    return u && h.success && await this.cacheManager.set(c, h, { ttl: l?.ttl }), h;
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private helpers
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Parses arguments for the get() method.
+   */
+  parseConfigArgs(e, t, s) {
+    if (typeof t == "string")
+      return {
+        brand: e,
+        config: t,
+        requestOptions: s
+      };
+    const n = this.parsePath(e, 2);
+    return {
+      brand: n[0],
+      config: n[1],
+      requestOptions: t
+    };
+  }
+  /**
+   * Parses arguments for the getValue() method.
+   */
+  parseValueArgs(e, t, s, n) {
+    if (typeof t == "string")
+      return {
+        brand: e,
+        config: t,
+        key: s,
+        requestOptions: n
+      };
+    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 n = t === 2 ? "brandName.configName" : "brandName.configName.keyName";
+      throw new Error(`Invalid path format "${e}". Expected "${n}"`);
+    }
+    return s;
+  }
+  /**
+   * Builds the URL for fetching an entire config.
+   */
+  buildConfigUrl(e, t) {
+    return `${I}/${this.encode(e)}/configs/${this.encode(t)}`;
+  }
+  /**
+   * Builds the URL for fetching a single value.
+   */
+  buildValueUrl(e, t, s) {
+    return `${I}/${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 $ = "/api/sdk";
+class N {
+  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(
+      `${$}/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(`${$}/introspect`, e);
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private helpers
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Builds URL path for brand-level endpoints.
+   */
+  buildBrandUrl(e, t = "") {
+    return `${$}/brands/${this.encode(e)}${t}`;
+  }
+  /**
+   * Builds URL path for config-level endpoints.
+   */
+  buildConfigUrl(e, t, s = "") {
+    return `${$}/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 x {
+  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 n = s?.ttl ?? this.ttl, a = {
+      value: t,
+      timestamp: Date.now(),
+      expiresAt: Date.now() + n
+    };
+    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, n] of this.cache.entries())
+      n.expiresAt < t && (t = n.expiresAt, e = s);
+    e && this.cache.delete(e);
+  }
+}
+class U {
+  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 L {
+  constructor(e) {
+    if (this.prefix = "dinoconfig:", e === "localStorage")
+      this.adapter = new U();
+    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 n = s?.ttl ?? 3e5, a = {
+        value: t,
+        timestamp: Date.now(),
+        expiresAt: Date.now() + n
+      };
+      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), n = this.adapter.storage;
+      if (!n)
+        return;
+      const a = [];
+      for (let r = 0; r < n.length; r++) {
+        const o = n.key(r);
+        if (o && o.startsWith(this.prefix)) {
+          const l = o.substring(this.prefix.length);
+          t.test(l) && a.push(o);
+        }
+      }
+      for (const r of a)
+        this.adapter.removeItem(r);
+    } 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 O {
+  constructor(e) {
+    if (this.config = e, !e.enabled) {
+      this.memoryCache = new x(0, 0);
+      return;
+    }
+    if (this.memoryCache = new x(
+      e.ttl,
+      e.maxSize
+    ), e.storage && e.storage !== "memory")
+      try {
+        this.storageCache = new L(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 n = await t();
+    return await this.set(e, n), n;
+  }
+}
+async function S(i) {
+  const {
+    apiKey: e,
+    baseUrl: t = "http://localhost:3000",
+    timeout: s = 1e4,
+    cache: n
+  } = i, a = new R(t, s);
+  await a.configureAuthorizationHeader({
+    "X-API-Key": e
+  });
+  const r = new O({
+    enabled: n?.enabled ?? !1,
+    ttl: n?.ttl ?? 6e4,
+    maxSize: n?.maxSize ?? 1e3,
+    storage: n?.storage,
+    staleWhileRevalidate: n?.staleWhileRevalidate ?? !1
+  });
+  return {
+    configs: new M(a, r),
+    discovery: new N(a),
+    cache: r
+  };
+}
+const _ = /* @__PURE__ */ new Set([
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "new",
+  "null",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with"
+]);
+function B(i) {
+  return i === "string" || i === "number" || i === "boolean";
+}
+class H {
+  constructor(e = T) {
+    this.namespace = e;
+  }
+  /**
+   * Generates the complete TypeScript declaration file content.
+   */
+  generate(e) {
+    const t = [
+      ...this.generateHeader(e),
+      "",
+      `export namespace ${this.namespace} {`
+    ];
+    for (const s of e.brands)
+      t.push(this.generateBrandNamespace(s)), t.push("");
+    return this.removeTrailingEmpty(t), t.push("}", "", ...this.generateHelperType(), ""), t.join(`
+`);
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private: Header & Helper Generation
+  // ─────────────────────────────────────────────────────────────────────────────
+  generateHeader(e) {
+    return [
+      "/**",
+      " * DinoConfig Generated Types",
+      " *",
+      ` * Auto-generated by ${v} v${j}`,
+      ` * Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      ` * Company: ${e.company}`,
+      " *",
+      " * DO NOT EDIT THIS FILE MANUALLY",
+      " * Run the codegen command to regenerate:",
+      ` *   npx ${v} codegen --api-key=<your-key> --output=<this-file>`,
+      " */"
+    ];
+  }
+  generateHelperType() {
+    return [
+      "/**",
+      " * Helper type to extract config type from namespace path",
+      " * @example",
+      ` * type Flags = ${this.namespace}.ConfigType<'MyBrand', 'FeatureFlags'>;`,
+      " */",
+      "export type ConfigType<",
+      `  Brand extends keyof typeof ${this.namespace},`,
+      `  Config extends keyof (typeof ${this.namespace})[Brand]`,
+      `> = (typeof ${this.namespace})[Brand][Config];`
+    ];
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private: Namespace & Interface Generation
+  // ─────────────────────────────────────────────────────────────────────────────
+  generateBrandNamespace(e) {
+    const t = this.sanitizeIdentifier(e.name), s = [
+      "  /**",
+      `   * ${e.name} brand configurations`,
+      "   * @namespace",
+      "   */",
+      `  export namespace ${t} {`
+    ];
+    for (const n of e.configs)
+      s.push(this.generateConfigInterface(n), "");
+    return this.removeTrailingEmpty(s), s.push("  }"), s.join(`
+`);
+  }
+  generateConfigInterface(e) {
+    const t = this.sanitizeIdentifier(e.name), s = [
+      "    /**",
+      `     * ${e.name} configuration`
+    ];
+    e.keys.length > 0 && s.push(`     * @property {${e.keys.length}} keys`), s.push("     */", `    export interface ${t} {`);
+    for (const n of e.keys)
+      s.push(...this.generateProperty(n));
+    return s.push("    }"), s.join(`
+`);
+  }
+  generateProperty(e) {
+    const t = this.sanitizeIdentifier(e.name), s = this.toTypeScriptType(e.type, e.value);
+    return [`      /** ${e.type} */`, `      ${t}: ${s};`];
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private: Type Conversion & Utilities
+  // ─────────────────────────────────────────────────────────────────────────────
+  toTypeScriptType(e, t) {
+    switch (e) {
+      case "boolean":
+      case "number":
+      case "string":
+        return e;
+      case "array":
+        return this.inferArrayType(t);
+      case "object":
+        return "Record<string, unknown>";
+      default:
+        return "unknown";
+    }
+  }
+  inferArrayType(e) {
+    if (Array.isArray(e) && e.length > 0) {
+      const t = typeof e[0];
+      if (B(t))
+        return `${t}[]`;
+    }
+    return "unknown[]";
+  }
+  sanitizeIdentifier(e) {
+    let t = e.replace(/[^a-zA-Z0-9_$]/g, "_");
+    return /^[0-9]/.test(t) && (t = "_" + t), _.has(t.toLowerCase()) && (t += "_"), t;
+  }
+  removeTrailingEmpty(e) {
+    for (; e.length > 0 && e[e.length - 1] === ""; )
+      e.pop();
+  }
+}
+const k = /* @__PURE__ */ new Set([
+  "abstract",
+  "assert",
+  "boolean",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "class",
+  "const",
+  "continue",
+  "default",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "extends",
+  "final",
+  "finally",
+  "float",
+  "for",
+  "goto",
+  "if",
+  "implements",
+  "import",
+  "instanceof",
+  "int",
+  "interface",
+  "long",
+  "native",
+  "new",
+  "null",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "short",
+  "static",
+  "strictfp",
+  "super",
+  "switch",
+  "synchronized",
+  "this",
+  "throw",
+  "throws",
+  "transient",
+  "try",
+  "void",
+  "volatile",
+  "while"
+]);
+function q(i) {
+  return i === "string" || i === "number" || i === "boolean";
+}
+const J = "com.dinoconfig.sdk.generated";
+function K(i) {
+  const e = i.replace(/\\/g, "/"), t = [
+    "src/main/java/",
+    "src/test/java/",
+    "src/java/",
+    "/java/"
+  ];
+  for (const s of t) {
+    const n = e.indexOf(s);
+    if (n !== -1) {
+      const a = e.substring(n + s.length);
+      if (a) {
+        const r = a.replace(/\/+$/, "").replace(/\//g, ".");
+        if (/^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)*$/i.test(r))
+          return r;
+      }
+    }
+  }
+}
+class G {
+  /**
+   * Creates a new JavaModelGenerator.
+   *
+   * @param options - Generator options
+   */
+  constructor(e = {}) {
+    this.generatedByComment = `Generated by ${v} v${j}`, this.basePackage = e.basePackage ?? J;
+  }
+  /**
+   * Gets the base package used by this generator.
+   */
+  getBasePackage() {
+    return this.basePackage;
+  }
+  /**
+   * Generates Java source files for each brand and config.
+   * Returns a map of file paths (relative to output directory) to file contents.
+   * The file paths only include brand subdirectories, not the base package path,
+   * since the output directory already represents the base package location.
+   */
+  generate(e) {
+    const t = /* @__PURE__ */ new Map();
+    for (const s of e.brands) {
+      const n = this.sanitizePackageName(s.name), a = `${this.basePackage}.${n}`;
+      for (const r of s.configs) {
+        const o = this.sanitizeClassName(r.name), l = `${n}/${o}.java`, c = this.generateConfigClass(a, o, r, s.name);
+        t.set(l, c);
+      }
+    }
+    return t;
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private: Class Generation
+  // ─────────────────────────────────────────────────────────────────────────────
+  generateConfigClass(e, t, s, n) {
+    const a = [
+      this.generateHeader(s, n),
+      "",
+      `package ${e};`,
+      "",
+      "import com.fasterxml.jackson.annotation.JsonProperty;",
+      "",
+      "import java.util.Objects;"
+    ], r = this.collectTypesUsed(s.keys);
+    (r.has("List") || r.has("Map")) && (r.has("List") && a.push("import java.util.List;"), r.has("Map") && a.push("import java.util.Map;"), a.push("import java.util.Collections;")), a.push("", this.generateClassDeclaration(t, s));
+    for (const o of s.keys)
+      a.push(this.generateField(o));
+    a.push("", this.generateDefaultConstructor(t, s.keys)), a.push("", this.generateFullConstructor(t, s.keys));
+    for (const o of s.keys)
+      a.push("", this.generateGetter(o));
+    return a.push("", this.generateEqualsMethod(t, s.keys)), a.push("", this.generateHashCodeMethod(s.keys)), a.push("", this.generateToStringMethod(t, s.keys)), a.push("}"), a.join(`
+`);
+  }
+  generateHeader(e, t) {
+    const s = (/* @__PURE__ */ new Date()).toISOString();
+    return `/*
+ * DinoConfig Java SDK - Generated Model
+ * ${this.generatedByComment}
+ * Generated at: ${s}
+ * 
+ * DO NOT EDIT THIS FILE MANUALLY
+ * This file is auto-generated from DinoConfig schema.
+ * 
+ * Brand: ${t}
+ * Config: ${e.name}
+ * Version: ${e.version}
+ */`;
+  }
+  generateClassDeclaration(e, t) {
+    const s = [
+      "/**",
+      ` * Generated model for ${t.name} configuration.`
+    ];
+    return t.description && s.push(" *", ` * ${t.description.replace(/\n/g, " ")}`), s.push(" *", " * <p>This class represents the typed structure of the configuration.", " * All fields are immutable.", " */"), s.push(`public final class ${e} {`), s.join(`
+`);
+  }
+  generateField(e) {
+    const t = this.sanitizeFieldName(e.name), s = this.toJavaType(e.type, e.value);
+    return [
+      "    /**",
+      `     * ${e.type} - ${e.name}`,
+      "     */",
+      `    @JsonProperty("${e.name}")`,
+      `    private final ${s} ${t};`
+    ].join(`
+`);
+  }
+  generateDefaultConstructor(e, t) {
+    const s = [
+      "    /**",
+      "     * Default constructor for Jackson deserialization.",
+      "     */",
+      `    public ${e}() {`
+    ];
+    for (const n of t) {
+      const a = this.sanitizeFieldName(n.name), r = this.toJavaType(n.type, n.value), o = this.getDefaultValue(r);
+      s.push(`        this.${a} = ${o};`);
+    }
+    return s.push("    }"), s.join(`
+`);
+  }
+  generateFullConstructor(e, t) {
+    const s = [];
+    for (const a of t) {
+      const r = this.sanitizeFieldName(a.name), o = this.toJavaType(a.type, a.value);
+      s.push(`${o} ${r}`);
+    }
+    const n = [
+      "    /**",
+      `     * Creates a new ${e} instance.`,
+      "     *"
+    ];
+    for (const a of t) {
+      const r = this.sanitizeFieldName(a.name);
+      n.push(`     * @param ${r} ${a.name} (${a.type})`);
+    }
+    n.push("     */", `    public ${e}(${s.join(", ")}) {`);
+    for (const a of t) {
+      const r = this.sanitizeFieldName(a.name), o = this.toJavaType(a.type, a.value);
+      o.startsWith("List<") ? n.push(`        this.${r} = ${r} != null ? Collections.unmodifiableList(${r}) : Collections.emptyList();`) : o.startsWith("Map<") ? n.push(`        this.${r} = ${r} != null ? Collections.unmodifiableMap(${r}) : Collections.emptyMap();`) : n.push(`        this.${r} = ${r};`);
+    }
+    return n.push("    }"), n.join(`
+`);
+  }
+  generateGetter(e) {
+    const t = this.sanitizeFieldName(e.name), s = this.toGetterName(t), n = this.toJavaType(e.type, e.value);
+    return [
+      "    /**",
+      `     * Returns ${e.name}.`,
+      "     *",
+      `     * @return ${e.name} (${e.type})`,
+      "     */",
+      `    public ${n} ${s}() {`,
+      `        return ${t};`,
+      "    }"
+    ].join(`
+`);
+  }
+  generateEqualsMethod(e, t) {
+    const s = [
+      "    @Override",
+      "    public boolean equals(Object o) {",
+      "        if (this == o) return true;",
+      "        if (o == null || getClass() != o.getClass()) return false;",
+      `        ${e} that = (${e}) o;`,
+      "        return "
+    ], n = [];
+    for (const a of t) {
+      const r = this.sanitizeFieldName(a.name);
+      n.push(`Objects.equals(${r}, that.${r})`);
+    }
+    return s.push("                " + n.join(`
+                && `)), s.push("        ;"), s.push("    }"), s.join(`
+`);
+  }
+  generateHashCodeMethod(e) {
+    return [
+      "    @Override",
+      "    public int hashCode() {",
+      `        return Objects.hash(${e.map((n) => this.sanitizeFieldName(n.name)).join(", ")});`,
+      "    }"
+    ].join(`
+`);
+  }
+  generateToStringMethod(e, t) {
+    if (t.length === 0)
+      return `    @Override
+    public String toString() {
+        return "${e}{}";
+    }`;
+    const s = [
+      "    @Override",
+      "    public String toString() {",
+      `        return "${e}{" +`
+    ];
+    for (let n = 0; n < t.length; n++) {
+      const a = t[n], r = this.sanitizeFieldName(a.name);
+      n === 0 ? s.push(`                "${r}=" + ${r}`) : s.push(`                + ", ${r}=" + ${r}`);
+    }
+    return s.push("                + '}';"), s.push("    }"), s.join(`
+`);
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private: Type Conversion & Utilities
+  // ─────────────────────────────────────────────────────────────────────────────
+  toJavaType(e, t) {
+    switch (e) {
+      case "boolean":
+        return "Boolean";
+      case "number":
+        return "Double";
+      // Use Double for numbers to handle both int and float
+      case "string":
+        return "String";
+      case "array":
+        return this.inferArrayType(t);
+      case "object":
+        return "Map<String, Object>";
+      default:
+        return "Object";
+    }
+  }
+  inferArrayType(e) {
+    if (Array.isArray(e) && e.length > 0) {
+      const t = typeof e[0];
+      if (q(t))
+        switch (t) {
+          case "boolean":
+            return "List<Boolean>";
+          case "number":
+            return "List<Double>";
+          case "string":
+            return "List<String>";
+        }
+    }
+    return "List<Object>";
+  }
+  getDefaultValue(e) {
+    switch (e) {
+      case "Boolean":
+        return "null";
+      case "Double":
+      case "Integer":
+      case "Long":
+        return "null";
+      case "String":
+        return "null";
+      case "List<Boolean>":
+      case "List<Double>":
+      case "List<String>":
+      case "List<Object>":
+        return "Collections.emptyList()";
+      case "Map<String, Object>":
+        return "Collections.emptyMap()";
+      default:
+        return "null";
+    }
+  }
+  sanitizeClassName(e) {
+    let t = e.replace(/[^a-zA-Z0-9]/g, "");
+    return t.length === 0 && (t = "Config"), /^[0-9]/.test(t) && (t = "Config" + t), t = t.charAt(0).toUpperCase() + t.slice(1), k.has(t.toLowerCase()) && (t += "Config"), t;
+  }
+  sanitizePackageName(e) {
+    return e.toLowerCase().replace(/[^a-z0-9]/g, "").replace(/^([0-9])/, "_$1");
+  }
+  sanitizeFieldName(e) {
+    let t = e.replace(/[^a-zA-Z0-9_$]/g, "_");
+    return t.length === 0 && (t = "value"), /^[0-9]/.test(t) && (t = "_" + t), t = t.replace(/_([a-z])/g, (s, n) => n.toUpperCase()), t.charAt(0).toUpperCase() === t.charAt(0) && /^[a-z]/.test(e) && (t = t.charAt(0).toLowerCase() + t.slice(1)), k.has(t.toLowerCase()) && (t += "_"), t;
+  }
+  toGetterName(e) {
+    return "get" + e.charAt(0).toUpperCase() + e.slice(1);
+  }
+  collectTypesUsed(e) {
+    const t = /* @__PURE__ */ new Set();
+    for (const s of e) {
+      const n = this.toJavaType(s.type, s.value);
+      n.startsWith("List<") && t.add("List"), n.startsWith("Map<") && t.add("Map");
+    }
+    return t;
+  }
+  getFilePath(e, t) {
+    return `${e.replace(/\./g, "/")}/${t}.java`;
+  }
+}
+const w = [
+  {
+    groupId: "com.fasterxml.jackson.core",
+    artifactId: "jackson-databind",
+    version: "2.16.1",
+    scope: "implementation"
+  },
+  {
+    groupId: "com.fasterxml.jackson.core",
+    artifactId: "jackson-annotations",
+    version: "2.16.1",
+    scope: "implementation"
+  }
+];
+function V(i) {
+  let e = p.resolve(i);
+  const t = 10;
+  let s = 0;
+  for (; s < t; ) {
+    const n = p.join(e, "build.gradle");
+    if (f.existsSync(n))
+      return { projectRoot: e, buildFile: n, projectType: "gradle" };
+    const a = p.join(e, "build.gradle.kts");
+    if (f.existsSync(a))
+      return { projectRoot: e, buildFile: a, projectType: "gradle" };
+    const r = p.join(e, "pom.xml");
+    if (f.existsSync(r))
+      return { projectRoot: e, buildFile: r, projectType: "maven" };
+    const o = p.dirname(e);
+    if (o === e)
+      break;
+    e = o, s++;
+  }
+  return null;
+}
+function W(i, e) {
+  return [
+    // Standard format: implementation 'group:artifact:version'
+    new RegExp(`['"]${g(e.groupId)}:${g(e.artifactId)}:[^'"]+['"]`),
+    // Without version (e.g., using BOM or version catalog)
+    new RegExp(`['"]${g(e.groupId)}:${g(e.artifactId)}['"]`),
+    // Gradle Kotlin DSL format
+    new RegExp(`"${g(e.groupId)}:${g(e.artifactId)}:[^"]+"`)
+  ].some((s) => s.test(i));
+}
+function Z(i, e) {
+  const t = `<groupId>${g(e.groupId)}</groupId>`, s = `<artifactId>${g(e.artifactId)}</artifactId>`;
+  return i.includes(e.groupId) && i.includes(e.artifactId) && new RegExp(t).test(i) && new RegExp(s).test(i);
+}
+function g(i) {
+  return i.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function X(i, e, t) {
+  const s = [], n = [];
+  for (const a of e) {
+    const r = `${a.groupId}:${a.artifactId}`;
+    if (W(i, a)) {
+      n.push(r);
+      continue;
+    }
+    const l = /dependencies\s*\{/.exec(i);
+    if (l) {
+      const c = l.index + l[0].length, u = t ? '"' : "'", h = `
+    ${a.scope}(${u}${a.groupId}:${a.artifactId}:${a.version}${u})`;
+      i = i.slice(0, c) + h + i.slice(c), s.push(r);
+    }
+  }
+  return { content: i, added: s, existing: n };
+}
+function Y(i, e) {
+  const t = [], s = [];
+  for (const n of e) {
+    const a = `${n.groupId}:${n.artifactId}`;
+    if (Z(i, n)) {
+      s.push(a);
+      continue;
+    }
+    const o = /<dependencies>/.exec(i);
+    if (o) {
+      const l = o.index + o[0].length, c = `
+        <dependency>
+            <groupId>${n.groupId}</groupId>
+            <artifactId>${n.artifactId}</artifactId>
+            <version>${n.version}</version>
+        </dependency>`;
+      i = i.slice(0, l) + c + i.slice(l), t.push(a);
+    } else {
+      const c = /<\/project>/.exec(i);
+      if (c) {
+        const u = c.index, h = `
+    <dependencies>
+        <dependency>
+            <groupId>${n.groupId}</groupId>
+            <artifactId>${n.artifactId}</artifactId>
+            <version>${n.version}</version>
+        </dependency>
+    </dependencies>
+`;
+        i = i.slice(0, u) + h + i.slice(u), t.push(a);
+      }
+    }
+  }
+  return { content: i, added: t, existing: s };
+}
+function Q(i, e = !1) {
+  const t = [], s = V(i);
+  if (!s)
+    return {
+      success: !1,
+      projectType: "unknown",
+      error: "Could not find build.gradle, build.gradle.kts, or pom.xml in the project hierarchy. Please manually add the Jackson dependency to your project.",
+      warnings: [
+        "For Gradle: implementation 'com.fasterxml.jackson.core:jackson-databind:2.16.1'",
+        "For Maven: <dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId><version>2.16.1</version></dependency>"
+      ]
+    };
+  const { projectRoot: n, buildFile: a, projectType: r } = s, o = a.endsWith(".kts");
+  try {
+    const l = f.readFileSync(a, "utf-8");
+    let c;
+    return r === "gradle" ? c = X(l, w, o) : c = Y(l, w), c.added.length > 0 && !e && f.writeFileSync(a, c.content, "utf-8"), c.existing.length > 0 && t.push(`Already present: ${c.existing.join(", ")}`), {
+      success: !0,
+      projectType: r,
+      buildFilePath: a,
+      addedDependencies: c.added,
+      existingDependencies: c.existing,
+      warnings: t.length > 0 ? t : void 0
+    };
+  } catch (l) {
+    return {
+      success: !1,
+      projectType: r,
+      buildFilePath: a,
+      error: l instanceof Error ? l.message : "Failed to update build file"
+    };
+  }
+}
+function te() {
+  return [...w];
+}
+function se(i, e = w) {
+  return i === "gradle" ? e.map(
+    (t) => `implementation '${t.groupId}:${t.artifactId}:${t.version}'`
+  ) : e.map(
+    (t) => `<dependency>
+  <groupId>${t.groupId}</groupId>
+  <artifactId>${t.artifactId}</artifactId>
+  <version>${t.version}</version>
+</dependency>`
+  );
+}
+function E(i) {
+  const e = p.dirname(i);
+  f.existsSync(e) || f.mkdirSync(e, { recursive: !0 });
+}
+function D(i) {
+  let e = 0, t = 0;
+  for (const s of i) {
+    e += s.configs.length;
+    for (const n of s.configs)
+      t += n.keys.length;
+  }
+  return { configs: e, keys: t };
+}
+async function ne(i) {
+  const {
+    apiKey: e,
+    baseUrl: t = A,
+    output: s = z,
+    namespace: n = T
+  } = i;
+  try {
+    const r = await (await S({ apiKey: e, baseUrl: t })).discovery.introspect();
+    if (!r.success || !r.data)
+      return {
+        success: !1,
+        error: r.message || "Failed to fetch introspection data"
+      };
+    const { brands: o } = r.data, { configs: l, keys: c } = D(o), h = new H(n).generate(r.data), d = p.resolve(process.cwd(), s);
+    return E(d), f.writeFileSync(d, h, "utf-8"), {
+      success: !0,
+      outputPath: d,
+      content: h,
+      stats: {
+        brands: o.length,
+        configs: l,
+        keys: c
+      }
+    };
+  } catch (a) {
+    return {
+      success: !1,
+      error: a instanceof Error ? a.message : "Unknown error"
+    };
+  }
+}
+async function ae(i) {
+  const {
+    apiKey: e,
+    baseUrl: t = A,
+    output: s = "./libs/dinoconfig-java-sdk/lib/src/main/java/com/dinoconfig/sdk/generated",
+    skipDependencyUpdate: n = !1
+  } = i;
+  try {
+    const r = await (await S({ apiKey: e, baseUrl: t })).discovery.introspect();
+    if (!r.success || !r.data)
+      return {
+        success: !1,
+        error: r.message || "Failed to fetch introspection data"
+      };
+    const { brands: o } = r.data, { configs: l, keys: c } = D(o), u = p.resolve(process.cwd(), s), h = i.package ?? K(u), d = new G({ basePackage: h }), m = d.generate(r.data), y = [];
+    for (const [P, F] of m.entries()) {
+      const C = p.join(u, P);
+      E(C), f.writeFileSync(C, F, "utf-8"), y.push(C);
+    }
+    let b;
+    return n || (b = Q(u)), {
+      success: !0,
+      outputDir: u,
+      generatedFiles: y,
+      stats: {
+        brands: o.length,
+        configs: l,
+        keys: c
+      },
+      dependencyUpdate: b,
+      basePackage: d.getBasePackage()
+    };
+  } catch (a) {
+    return {
+      success: !1,
+      error: a instanceof Error ? a.message : "Unknown error"
+    };
+  }
+}
+export {
+  G as J,
+  H as T,
+  ne as a,
+  te as b,
+  K as d,
+  se as f,
+  ae as g,
+  Q as u
+};