@smplkit/sdk 1.0.0 → 1.1.0

package/dist/index.cjs

@@ -0,0 +1,874 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config/resolve.ts
+function deepMerge(base, override) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    if (key in result && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key]) && typeof value === "object" && value !== null && !Array.isArray(value)) {
+      result[key] = deepMerge(
+        result[key],
+        value
+      );
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function resolveChain(chain, environment) {
+  let accumulated = {};
+  for (let i = chain.length - 1; i >= 0; i--) {
+    const config = chain[i];
+    const baseValues = config.values ?? {};
+    const envEntry = (config.environments ?? {})[environment];
+    const envValues = envEntry !== null && envEntry !== void 0 && typeof envEntry === "object" && !Array.isArray(envEntry) ? envEntry.values ?? {} : {};
+    const configResolved = deepMerge(baseValues, envValues);
+    accumulated = deepMerge(accumulated, configResolved);
+  }
+  return accumulated;
+}
+var init_resolve = __esm({
+  "src/config/resolve.ts"() {
+    "use strict";
+  }
+});
+
+// src/config/runtime.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  ConfigRuntime: () => ConfigRuntime
+});
+var import_ws, BACKOFF_MS, ConfigRuntime;
+var init_runtime = __esm({
+  "src/config/runtime.ts"() {
+    "use strict";
+    import_ws = __toESM(require("ws"), 1);
+    init_resolve();
+    BACKOFF_MS = [1e3, 2e3, 4e3, 8e3, 16e3, 32e3, 6e4];
+    ConfigRuntime = class {
+      _cache;
+      _chain;
+      _fetchCount;
+      _lastFetchAt;
+      _closed = false;
+      _wsStatus = "disconnected";
+      _ws = null;
+      _reconnectTimer = null;
+      _backoffIndex = 0;
+      _listeners = [];
+      _configId;
+      _environment;
+      _apiKey;
+      _baseUrl;
+      _fetchChain;
+      /** @internal */
+      constructor(options) {
+        this._configId = options.configId;
+        this._environment = options.environment;
+        this._apiKey = options.apiKey;
+        this._baseUrl = options.baseUrl;
+        this._fetchChain = options.fetchChain;
+        this._chain = options.chain;
+        this._cache = resolveChain(options.chain, options.environment);
+        this._fetchCount = options.chain.length;
+        this._lastFetchAt = (/* @__PURE__ */ new Date()).toISOString();
+        this._connectWebSocket();
+      }
+      // ---- Value access (synchronous, local cache) ----
+      /**
+       * Return the resolved value for `key`, or `defaultValue` if absent.
+       *
+       * @param key - The config key to look up.
+       * @param defaultValue - Returned when the key is not present (default: null).
+       */
+      get(key, defaultValue = null) {
+        return key in this._cache ? this._cache[key] : defaultValue;
+      }
+      /**
+       * Return the value as a string, or `defaultValue` if absent or not a string.
+       */
+      getString(key, defaultValue = null) {
+        const value = this._cache[key];
+        return typeof value === "string" ? value : defaultValue;
+      }
+      /**
+       * Return the value as a number, or `defaultValue` if absent or not a number.
+       */
+      getNumber(key, defaultValue = null) {
+        const value = this._cache[key];
+        return typeof value === "number" ? value : defaultValue;
+      }
+      /**
+       * Return the value as a boolean, or `defaultValue` if absent or not a boolean.
+       */
+      getBool(key, defaultValue = null) {
+        const value = this._cache[key];
+        return typeof value === "boolean" ? value : defaultValue;
+      }
+      /**
+       * Return whether `key` is present in the resolved configuration.
+       */
+      exists(key) {
+        return key in this._cache;
+      }
+      /**
+       * Return a shallow copy of the full resolved configuration.
+       */
+      getAll() {
+        return { ...this._cache };
+      }
+      // ---- Change listeners ----
+      /**
+       * Register a listener that fires when a config value changes.
+       *
+       * @param callback - Called with a {@link ConfigChangeEvent} on each change.
+       * @param options.key - If provided, the listener fires only for this key.
+       *   If omitted, the listener fires for all changes.
+       */
+      onChange(callback, options) {
+        this._listeners.push({
+          callback,
+          key: options?.key ?? null
+        });
+      }
+      // ---- Diagnostics ----
+      /**
+       * Return diagnostic statistics for this runtime.
+       */
+      stats() {
+        return {
+          fetchCount: this._fetchCount,
+          lastFetchAt: this._lastFetchAt
+        };
+      }
+      /**
+       * Return the current WebSocket connection status.
+       */
+      connectionStatus() {
+        return this._wsStatus;
+      }
+      // ---- Lifecycle ----
+      /**
+       * Force a manual refresh of the cached configuration.
+       *
+       * Re-fetches the full config chain via HTTP, re-resolves values, updates
+       * the local cache, and fires listeners for any detected changes.
+       *
+       * @throws {Error} If no `fetchChain` function was provided on construction.
+       */
+      async refresh() {
+        if (!this._fetchChain) {
+          throw new Error("No fetchChain function provided; cannot refresh.");
+        }
+        const newChain = await this._fetchChain();
+        const oldCache = this._cache;
+        this._chain = newChain;
+        this._cache = resolveChain(newChain, this._environment);
+        this._fetchCount += newChain.length;
+        this._lastFetchAt = (/* @__PURE__ */ new Date()).toISOString();
+        this._diffAndFire(oldCache, this._cache, "manual");
+      }
+      /**
+       * Close the runtime connection.
+       *
+       * Shuts down the WebSocket and cancels any pending reconnect timer.
+       * Safe to call multiple times.
+       */
+      async close() {
+        this._closed = true;
+        this._wsStatus = "disconnected";
+        if (this._reconnectTimer !== null) {
+          clearTimeout(this._reconnectTimer);
+          this._reconnectTimer = null;
+        }
+        if (this._ws !== null) {
+          this._ws.close();
+          this._ws = null;
+        }
+      }
+      /**
+       * Async dispose support for `await using` (TypeScript 5.2+).
+       */
+      async [Symbol.asyncDispose]() {
+        await this.close();
+      }
+      // ---- WebSocket internals ----
+      _buildWsUrl() {
+        let url = this._baseUrl;
+        if (url.startsWith("https://")) {
+          url = "wss://" + url.slice("https://".length);
+        } else if (url.startsWith("http://")) {
+          url = "ws://" + url.slice("http://".length);
+        } else {
+          url = "wss://" + url;
+        }
+        url = url.replace(/\/$/, "");
+        return `${url}/api/ws/v1/configs?api_key=${this._apiKey}`;
+      }
+      _connectWebSocket() {
+        if (this._closed) return;
+        this._wsStatus = "connecting";
+        const wsUrl = this._buildWsUrl();
+        try {
+          const ws = new import_ws.default(wsUrl);
+          this._ws = ws;
+          ws.on("open", () => {
+            if (this._closed) {
+              ws.close();
+              return;
+            }
+            this._backoffIndex = 0;
+            this._wsStatus = "connected";
+            ws.send(
+              JSON.stringify({
+                type: "subscribe",
+                config_id: this._configId,
+                environment: this._environment
+              })
+            );
+          });
+          ws.on("message", (data) => {
+            try {
+              const msg = JSON.parse(String(data));
+              this._handleMessage(msg);
+            } catch {
+            }
+          });
+          ws.on("close", () => {
+            if (!this._closed) {
+              this._wsStatus = "disconnected";
+              this._scheduleReconnect();
+            }
+          });
+          ws.on("error", () => {
+          });
+        } catch {
+          if (!this._closed) {
+            this._scheduleReconnect();
+          }
+        }
+      }
+      _scheduleReconnect() {
+        if (this._closed) return;
+        const delay = BACKOFF_MS[Math.min(this._backoffIndex, BACKOFF_MS.length - 1)];
+        this._backoffIndex++;
+        this._wsStatus = "connecting";
+        this._reconnectTimer = setTimeout(() => {
+          this._reconnectTimer = null;
+          if (this._fetchChain) {
+            this._fetchChain().then((newChain) => {
+              const oldCache = this._cache;
+              this._chain = newChain;
+              this._cache = resolveChain(newChain, this._environment);
+              this._fetchCount += newChain.length;
+              this._lastFetchAt = (/* @__PURE__ */ new Date()).toISOString();
+              this._diffAndFire(oldCache, this._cache, "manual");
+            }).catch(() => {
+            }).finally(() => {
+              this._connectWebSocket();
+            });
+          } else {
+            this._connectWebSocket();
+          }
+        }, delay);
+      }
+      _handleMessage(msg) {
+        if (msg.type === "config_changed") {
+          this._applyChanges(msg.config_id, msg.changes);
+        } else if (msg.type === "config_deleted") {
+          this._closed = true;
+          void this.close();
+        }
+      }
+      _applyChanges(configId, changes) {
+        const chainEntry = this._chain.find((c) => c.id === configId);
+        if (!chainEntry) return;
+        for (const change of changes) {
+          const { key, new_value } = change;
+          const envEntry = chainEntry.environments[this._environment] !== void 0 && chainEntry.environments[this._environment] !== null ? chainEntry.environments[this._environment] : null;
+          const envValues = envEntry !== null && typeof envEntry === "object" ? envEntry.values ?? {} : null;
+          if (new_value === null || new_value === void 0) {
+            delete chainEntry.values[key];
+            if (envValues) delete envValues[key];
+          } else if (envValues && key in envValues) {
+            envValues[key] = new_value;
+          } else if (key in chainEntry.values) {
+            chainEntry.values[key] = new_value;
+          } else {
+            chainEntry.values[key] = new_value;
+          }
+        }
+        const oldCache = this._cache;
+        this._cache = resolveChain(this._chain, this._environment);
+        this._diffAndFire(oldCache, this._cache, "websocket");
+      }
+      _diffAndFire(oldCache, newCache, source) {
+        const allKeys = /* @__PURE__ */ new Set([...Object.keys(oldCache), ...Object.keys(newCache)]);
+        for (const key of allKeys) {
+          const oldVal = key in oldCache ? oldCache[key] : null;
+          const newVal = key in newCache ? newCache[key] : null;
+          if (JSON.stringify(oldVal) !== JSON.stringify(newVal)) {
+            const event = { key, oldValue: oldVal, newValue: newVal, source };
+            this._fireListeners(event);
+          }
+        }
+      }
+      _fireListeners(event) {
+        for (const listener of this._listeners) {
+          if (listener.key === null || listener.key === event.key) {
+            try {
+              listener.callback(event);
+            } catch {
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Config: () => Config,
+  ConfigClient: () => ConfigClient,
+  ConfigRuntime: () => ConfigRuntime,
+  SmplConflictError: () => SmplConflictError,
+  SmplConnectionError: () => SmplConnectionError,
+  SmplError: () => SmplError,
+  SmplNotFoundError: () => SmplNotFoundError,
+  SmplTimeoutError: () => SmplTimeoutError,
+  SmplValidationError: () => SmplValidationError,
+  SmplkitClient: () => SmplkitClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config/client.ts
+var import_openapi_fetch = __toESM(require("openapi-fetch"), 1);
+
+// src/errors.ts
+var SmplError = class extends Error {
+  /** The HTTP status code, if the error originated from an HTTP response. */
+  statusCode;
+  /** The raw response body, if available. */
+  responseBody;
+  constructor(message, statusCode, responseBody) {
+    super(message);
+    this.name = "SmplError";
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var SmplConnectionError = class extends SmplError {
+  constructor(message, statusCode, responseBody) {
+    super(message, statusCode, responseBody);
+    this.name = "SmplConnectionError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var SmplTimeoutError = class extends SmplError {
+  constructor(message, statusCode, responseBody) {
+    super(message, statusCode, responseBody);
+    this.name = "SmplTimeoutError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var SmplNotFoundError = class extends SmplError {
+  constructor(message, statusCode, responseBody) {
+    super(message, statusCode ?? 404, responseBody);
+    this.name = "SmplNotFoundError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var SmplConflictError = class extends SmplError {
+  constructor(message, statusCode, responseBody) {
+    super(message, statusCode ?? 409, responseBody);
+    this.name = "SmplConflictError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var SmplValidationError = class extends SmplError {
+  constructor(message, statusCode, responseBody) {
+    super(message, statusCode ?? 422, responseBody);
+    this.name = "SmplValidationError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/config/types.ts
+var Config = class {
+  /** UUID of the config. */
+  id;
+  /** Human-readable key (e.g. `"user_service"`). */
+  key;
+  /** Display name. */
+  name;
+  /** Optional description. */
+  description;
+  /** Parent config UUID, or null if this is a root config. */
+  parent;
+  /** Base key-value pairs. */
+  values;
+  /**
+   * Per-environment overrides.
+   * Stored as `{ env_name: { values: { key: value } } }` to match the
+   * server's format.
+   */
+  environments;
+  /** When the config was created, or null if unavailable. */
+  createdAt;
+  /** When the config was last updated, or null if unavailable. */
+  updatedAt;
+  /**
+   * Internal reference to the parent client.
+   * @internal
+   */
+  _client;
+  /** @internal */
+  constructor(client, fields) {
+    this._client = client;
+    this.id = fields.id;
+    this.key = fields.key;
+    this.name = fields.name;
+    this.description = fields.description;
+    this.parent = fields.parent;
+    this.values = fields.values;
+    this.environments = fields.environments;
+    this.createdAt = fields.createdAt;
+    this.updatedAt = fields.updatedAt;
+  }
+  /**
+   * Update this config's attributes on the server.
+   *
+   * Builds the request from current attribute values, overriding with any
+   * provided options. Updates local attributes in place on success.
+   *
+   * @param options.name - New display name.
+   * @param options.description - New description (pass empty string to clear).
+   * @param options.values - New base values (replaces entirely).
+   * @param options.environments - New environments dict (replaces entirely).
+   */
+  async update(options) {
+    const updated = await this._client._updateConfig({
+      configId: this.id,
+      name: options.name ?? this.name,
+      key: this.key,
+      description: options.description !== void 0 ? options.description : this.description,
+      parent: this.parent,
+      values: options.values ?? this.values,
+      environments: options.environments ?? this.environments
+    });
+    this.name = updated.name;
+    this.description = updated.description;
+    this.values = updated.values;
+    this.environments = updated.environments;
+    this.updatedAt = updated.updatedAt;
+  }
+  /**
+   * Replace base or environment-specific values.
+   *
+   * When `environment` is provided, replaces that environment's `values`
+   * sub-dict (other environments are preserved). When omitted, replaces
+   * the base `values`.
+   *
+   * @param values - The complete set of values to set.
+   * @param environment - Target environment, or omit for base values.
+   */
+  async setValues(values, environment) {
+    let newValues;
+    let newEnvs;
+    if (environment === void 0) {
+      newValues = values;
+      newEnvs = this.environments;
+    } else {
+      newValues = this.values;
+      const existingEntry = typeof this.environments[environment] === "object" && this.environments[environment] !== null ? { ...this.environments[environment] } : {};
+      existingEntry.values = values;
+      newEnvs = { ...this.environments, [environment]: existingEntry };
+    }
+    const updated = await this._client._updateConfig({
+      configId: this.id,
+      name: this.name,
+      key: this.key,
+      description: this.description,
+      parent: this.parent,
+      values: newValues,
+      environments: newEnvs
+    });
+    this.values = updated.values;
+    this.environments = updated.environments;
+    this.updatedAt = updated.updatedAt;
+  }
+  /**
+   * Set a single key within base or environment-specific values.
+   *
+   * Merges the key into existing values rather than replacing all values.
+   *
+   * @param key - The config key to set.
+   * @param value - The value to assign.
+   * @param environment - Target environment, or omit for base values.
+   */
+  async setValue(key, value, environment) {
+    if (environment === void 0) {
+      const merged = { ...this.values, [key]: value };
+      await this.setValues(merged);
+    } else {
+      const envEntry = typeof this.environments[environment] === "object" && this.environments[environment] !== null ? this.environments[environment] : {};
+      const existing = {
+        ...typeof envEntry.values === "object" && envEntry.values !== null ? envEntry.values : {}
+      };
+      existing[key] = value;
+      await this.setValues(existing, environment);
+    }
+  }
+  /**
+   * Connect to this config for runtime value resolution.
+   *
+   * Eagerly fetches this config and its full parent chain, resolves values
+   * for the given environment via deep merge, and returns a
+   * {@link ConfigRuntime} with a fully populated local cache.
+   *
+   * A background WebSocket connection is started for real-time updates.
+   * If the WebSocket fails to connect, the runtime operates in cache-only
+   * mode and reconnects automatically.
+   *
+   * Supports both `await` and `await using` (TypeScript 5.2+)::
+   *
+   * ```typescript
+   * // Simple await
+   * const runtime = await config.connect("production");
+   * try { ... } finally { await runtime.close(); }
+   *
+   * // await using (auto-close)
+   * await using runtime = await config.connect("production");
+   * ```
+   *
+   * @param environment - The environment to resolve for (e.g. `"production"`).
+   * @param options.timeout - Milliseconds to wait for the initial fetch.
+   */
+  async connect(environment, options) {
+    const { ConfigRuntime: ConfigRuntime2 } = await Promise.resolve().then(() => (init_runtime(), runtime_exports));
+    const timeout = options?.timeout ?? 3e4;
+    const chain = await this._buildChain(timeout);
+    return new ConfigRuntime2({
+      configKey: this.key,
+      configId: this.id,
+      environment,
+      chain,
+      apiKey: this._client._apiKey,
+      baseUrl: this._client._baseUrl,
+      fetchChain: () => this._buildChain(timeout)
+    });
+  }
+  /**
+   * Walk the parent chain and return config data objects, child-to-root.
+   * @internal
+   */
+  async _buildChain(_timeout) {
+    const chain = [{ id: this.id, values: this.values, environments: this.environments }];
+    let parentId = this.parent;
+    while (parentId !== null) {
+      const parentConfig = await this._client.get({ id: parentId });
+      chain.push({
+        id: parentConfig.id,
+        values: parentConfig.values,
+        environments: parentConfig.environments
+      });
+      parentId = parentConfig.parent;
+    }
+    return chain;
+  }
+  toString() {
+    return `Config(id=${this.id}, key=${this.key}, name=${this.name})`;
+  }
+};
+
+// src/config/client.ts
+var BASE_URL = "https://config.smplkit.com";
+function resourceToConfig(resource, client) {
+  const attrs = resource.attributes;
+  return new Config(client, {
+    id: resource.id ?? "",
+    key: attrs.key ?? "",
+    name: attrs.name,
+    description: attrs.description ?? null,
+    parent: attrs.parent ?? null,
+    values: attrs.values ?? {},
+    environments: attrs.environments ?? {},
+    createdAt: attrs.created_at ? new Date(attrs.created_at) : null,
+    updatedAt: attrs.updated_at ? new Date(attrs.updated_at) : null
+  });
+}
+async function checkError(response, context) {
+  const body = await response.text().catch(() => "");
+  switch (response.status) {
+    case 404:
+      throw new SmplNotFoundError(body || context, 404, body);
+    case 409:
+      throw new SmplConflictError(body || context, 409, body);
+    case 422:
+      throw new SmplValidationError(body || context, 422, body);
+    default:
+      throw new SmplError(`HTTP ${response.status}: ${body}`, response.status, body);
+  }
+}
+function wrapFetchError(err) {
+  if (err instanceof SmplNotFoundError || err instanceof SmplConflictError || err instanceof SmplValidationError || err instanceof SmplError) {
+    throw err;
+  }
+  if (err instanceof TypeError) {
+    throw new SmplConnectionError(`Network error: ${err.message}`);
+  }
+  throw new SmplConnectionError(
+    `Request failed: ${err instanceof Error ? err.message : String(err)}`
+  );
+}
+function buildRequestBody(options) {
+  const attrs = {
+    name: options.name
+  };
+  if (options.key !== void 0) attrs.key = options.key;
+  if (options.description !== void 0) attrs.description = options.description;
+  if (options.parent !== void 0) attrs.parent = options.parent;
+  if (options.values !== void 0)
+    attrs.values = options.values;
+  if (options.environments !== void 0)
+    attrs.environments = options.environments;
+  return {
+    data: {
+      id: options.id ?? null,
+      type: "config",
+      attributes: attrs
+    }
+  };
+}
+var ConfigClient = class {
+  /** @internal — used by Config instances for reconnecting and WebSocket auth. */
+  _apiKey;
+  /** @internal */
+  _baseUrl = BASE_URL;
+  /** @internal */
+  _http;
+  /** @internal */
+  constructor(apiKey, timeout) {
+    this._apiKey = apiKey;
+    const ms = timeout ?? 3e4;
+    this._http = (0, import_openapi_fetch.default)({
+      baseUrl: BASE_URL,
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json"
+      },
+      // openapi-fetch custom fetch receives a pre-built Request object
+      fetch: async (request) => {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), ms);
+        try {
+          return await fetch(new Request(request, { signal: controller.signal }));
+        } catch (err) {
+          if (err instanceof DOMException && err.name === "AbortError") {
+            throw new SmplTimeoutError(`Request timed out after ${ms}ms`);
+          }
+          throw err;
+        } finally {
+          clearTimeout(timer);
+        }
+      }
+    });
+  }
+  /**
+   * Fetch a single config by key or UUID.
+   *
+   * Exactly one of `key` or `id` must be provided.
+   *
+   * @throws {SmplNotFoundError} If no matching config exists.
+   */
+  async get(options) {
+    const { key, id } = options;
+    if (key === void 0 === (id === void 0)) {
+      throw new Error("Exactly one of 'key' or 'id' must be provided.");
+    }
+    return id !== void 0 ? this._getById(id) : this._getByKey(key);
+  }
+  /**
+   * List all configs for the account.
+   */
+  async list() {
+    let data;
+    try {
+      const result = await this._http.GET("/api/v1/configs", {});
+      if (result.error !== void 0) await checkError(result.response, "Failed to list configs");
+      data = result.data;
+    } catch (err) {
+      wrapFetchError(err);
+    }
+    if (!data) return [];
+    return data.data.map((r) => resourceToConfig(r, this));
+  }
+  /**
+   * Create a new config.
+   *
+   * @throws {SmplValidationError} If the server rejects the request.
+   */
+  async create(options) {
+    const body = buildRequestBody({
+      name: options.name,
+      key: options.key,
+      description: options.description,
+      parent: options.parent,
+      values: options.values
+    });
+    let data;
+    try {
+      const result = await this._http.POST("/api/v1/configs", { body });
+      if (result.error !== void 0) await checkError(result.response, "Failed to create config");
+      data = result.data;
+    } catch (err) {
+      wrapFetchError(err);
+    }
+    if (!data || !data.data) throw new SmplValidationError("Failed to create config");
+    return resourceToConfig(data.data, this);
+  }
+  /**
+   * Delete a config by UUID.
+   *
+   * @throws {SmplNotFoundError} If the config does not exist.
+   * @throws {SmplConflictError} If the config has child configs.
+   */
+  async delete(configId) {
+    try {
+      const result = await this._http.DELETE("/api/v1/configs/{id}", {
+        params: { path: { id: configId } }
+      });
+      if (result.error !== void 0 && result.response.status !== 204)
+        await checkError(result.response, `Failed to delete config ${configId}`);
+    } catch (err) {
+      wrapFetchError(err);
+    }
+  }
+  /**
+   * Internal: PUT a full config update and return the updated model.
+   *
+   * Called by {@link Config} instance methods.
+   * @internal
+   */
+  async _updateConfig(payload) {
+    const body = buildRequestBody({
+      id: payload.configId,
+      name: payload.name,
+      key: payload.key,
+      description: payload.description,
+      parent: payload.parent,
+      values: payload.values,
+      environments: payload.environments
+    });
+    let data;
+    try {
+      const result = await this._http.PUT("/api/v1/configs/{id}", {
+        params: { path: { id: payload.configId } },
+        body
+      });
+      if (result.error !== void 0)
+        await checkError(result.response, `Failed to update config ${payload.configId}`);
+      data = result.data;
+    } catch (err) {
+      wrapFetchError(err);
+    }
+    if (!data || !data.data)
+      throw new SmplValidationError(`Failed to update config ${payload.configId}`);
+    return resourceToConfig(data.data, this);
+  }
+  // ---- Private helpers ----
+  async _getById(configId) {
+    let data;
+    try {
+      const result = await this._http.GET("/api/v1/configs/{id}", {
+        params: { path: { id: configId } }
+      });
+      if (result.error !== void 0)
+        await checkError(result.response, `Config ${configId} not found`);
+      data = result.data;
+    } catch (err) {
+      wrapFetchError(err);
+    }
+    if (!data || !data.data) throw new SmplNotFoundError(`Config ${configId} not found`);
+    return resourceToConfig(data.data, this);
+  }
+  async _getByKey(key) {
+    let data;
+    try {
+      const result = await this._http.GET("/api/v1/configs", {
+        params: { query: { "filter[key]": key } }
+      });
+      if (result.error !== void 0)
+        await checkError(result.response, `Config with key '${key}' not found`);
+      data = result.data;
+    } catch (err) {
+      wrapFetchError(err);
+    }
+    if (!data || !data.data || data.data.length === 0) {
+      throw new SmplNotFoundError(`Config with key '${key}' not found`);
+    }
+    return resourceToConfig(data.data[0], this);
+  }
+};
+
+// src/client.ts
+var SmplkitClient = class {
+  /** Client for config management-plane operations. */
+  config;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("apiKey is required");
+    }
+    this.config = new ConfigClient(options.apiKey, options.timeout);
+  }
+};
+
+// src/index.ts
+init_runtime();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  ConfigClient,
+  ConfigRuntime,
+  SmplConflictError,
+  SmplConnectionError,
+  SmplError,
+  SmplNotFoundError,
+  SmplTimeoutError,
+  SmplValidationError,
+  SmplkitClient
+});
+//# sourceMappingURL=index.cjs.map