@nexus-ai-fs/api-client 0.9.18

package/dist/index.js

@@ -0,0 +1,749 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/errors.ts
+var NexusApiError = class extends Error {
+  status;
+  code;
+  constructor(message, status, code) {
+    super(message);
+    this.name = "NexusApiError";
+    this.status = status;
+    this.code = code;
+  }
+};
+var AuthenticationError = class extends NexusApiError {
+  constructor(message) {
+    super(message, 401, "authentication_error");
+    this.name = "AuthenticationError";
+  }
+};
+var ForbiddenError = class extends NexusApiError {
+  constructor(message) {
+    super(message, 403, "forbidden");
+    this.name = "ForbiddenError";
+  }
+};
+var NotFoundError = class extends NexusApiError {
+  constructor(message) {
+    super(message, 404, "not_found");
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends NexusApiError {
+  constructor(message) {
+    super(message, 409, "conflict");
+    this.name = "ConflictError";
+  }
+};
+var RateLimitError = class extends NexusApiError {
+  retryAfter;
+  constructor(message, retryAfter) {
+    super(message, 429, "rate_limit_error");
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var ServerError = class extends NexusApiError {
+  constructor(message, status) {
+    super(message, status, "server_error");
+    this.name = "ServerError";
+  }
+};
+var NetworkError = class extends NexusApiError {
+  constructor(message) {
+    super(message, 0, "network_error");
+    this.name = "NetworkError";
+  }
+};
+var TimeoutError = class extends NexusApiError {
+  constructor(message) {
+    super(message, 0, "timeout_error");
+    this.name = "TimeoutError";
+  }
+};
+var AbortError = class extends NexusApiError {
+  constructor(message) {
+    super(message, 0, "abort_error");
+    this.name = "AbortError";
+  }
+};
+
+// src/case-transform.ts
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function transformKeys(value, transformer) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => transformKeys(item, transformer));
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  if (Object.getPrototypeOf(value) !== Object.prototype) {
+    return value;
+  }
+  const result = {};
+  for (const [key, val] of Object.entries(value)) {
+    result[transformer(key)] = transformKeys(val, transformer);
+  }
+  return result;
+}
+function snakeToCamelKeys(value) {
+  return transformKeys(value, snakeToCamel);
+}
+function camelToSnakeKeys(value) {
+  return transformKeys(value, camelToSnake);
+}
+
+// src/fetch-client.ts
+var DEFAULT_BASE_URL = "http://localhost:2026";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+var INITIAL_RETRY_DELAY = 500;
+var MAX_RETRY_DELAY = 8e3;
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var FetchClient = class {
+  apiKey;
+  baseUrl;
+  timeout;
+  maxRetries;
+  fetchFn;
+  transformEnabled;
+  agentId;
+  subject;
+  zoneId;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.fetchFn = options.fetch ?? globalThis.fetch;
+    this.transformEnabled = options.transformKeys ?? true;
+    this.agentId = options.agentId;
+    this.subject = options.subject;
+    this.zoneId = options.zoneId;
+  }
+  async get(path, options) {
+    return this.request("GET", path, void 0, options);
+  }
+  async post(path, body, options) {
+    return this.request("POST", path, body, options);
+  }
+  async put(path, body, options) {
+    return this.request("PUT", path, body, options);
+  }
+  async patch(path, body, options) {
+    return this.request("PATCH", path, body, options);
+  }
+  async delete(path, options) {
+    return this.request("DELETE", path, void 0, options);
+  }
+  async postNoContent(path, body, options) {
+    await this.requestRaw("POST", path, body, options);
+  }
+  async deleteNoContent(path, options) {
+    await this.requestRaw("DELETE", path, void 0, options);
+  }
+  /**
+   * Execute an arbitrary HTTP request through the authenticated client.
+   *
+   * Returns the raw `Response` — no JSON parsing, no key transformation,
+   * no retries. Auth and identity headers are injected automatically.
+   * Timeout is enforced (defaults to client timeout, overridable per-request).
+   *
+   * Body is sent as-is (no JSON.stringify) since callers provide pre-formatted strings.
+   *
+   * Intended for the API Console and similar exploratory tools that need
+   * full control over the request/response while still using real auth.
+   */
+  async rawRequest(method, path, body, options) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = this.buildHeaders(method, options);
+    const effectiveTimeout = options?.timeout ?? this.timeout;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), effectiveTimeout);
+    const userSignal = options?.signal;
+    const onUserAbort = () => controller.abort();
+    if (userSignal) {
+      if (userSignal.aborted) {
+        clearTimeout(timeoutId);
+        throw new AbortError("Request aborted");
+      }
+      userSignal.addEventListener("abort", onUserAbort, { once: true });
+    }
+    try {
+      return await this.fetchFn(url, {
+        method,
+        headers,
+        body: body ?? void 0,
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError") {
+        if (userSignal?.aborted) {
+          throw new AbortError("Request aborted");
+        }
+        throw new TimeoutError("Request timed out");
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+      if (userSignal) {
+        userSignal.removeEventListener("abort", onUserAbort);
+      }
+    }
+  }
+  // ===========================================================================
+  // Core request logic
+  // ===========================================================================
+  async request(method, path, body, options) {
+    const response = await this.requestRaw(method, path, body, options);
+    if (response.status === 204) {
+      return void 0;
+    }
+    const json = await response.json();
+    return this.transformEnabled ? snakeToCamelKeys(json) : json;
+  }
+  async requestRaw(method, path, body, options) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = this.buildHeaders(method, options);
+    const effectiveTimeout = options?.timeout ?? this.timeout;
+    const transformedBody = body !== void 0 && this.transformEnabled ? camelToSnakeKeys(body) : body;
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      if (attempt > 0 && lastError) {
+        const delay = this.computeRetryDelay(attempt, lastError);
+        await sleep(delay);
+      }
+      try {
+        const response = await this.executeFetch(
+          url,
+          method,
+          headers,
+          transformedBody,
+          effectiveTimeout,
+          options?.signal
+        );
+        if (response.ok || response.status === 204) {
+          return response;
+        }
+        const error = await this.buildError(response);
+        if (RETRYABLE_STATUS_CODES.has(response.status) && attempt < this.maxRetries) {
+          lastError = error;
+          continue;
+        }
+        throw error;
+      } catch (error) {
+        if (error instanceof NexusApiError && !RETRYABLE_STATUS_CODES.has(error.status)) {
+          throw error;
+        }
+        if (attempt < this.maxRetries) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          continue;
+        }
+        if (error instanceof NexusApiError) {
+          throw error;
+        }
+        throw new NetworkError(
+          error instanceof Error ? error.message : "Request failed"
+        );
+      }
+    }
+    throw lastError ?? new NetworkError("Request failed");
+  }
+  // ===========================================================================
+  // Helpers
+  // ===========================================================================
+  async executeFetch(url, method, headers, body, timeout, userSignal) {
+    if (userSignal?.aborted) {
+      throw new AbortError("Request aborted");
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const onUserAbort = () => controller.abort();
+    if (userSignal) {
+      userSignal.addEventListener("abort", onUserAbort, { once: true });
+    }
+    try {
+      return await this.fetchFn(url, {
+        method,
+        headers,
+        body: body !== void 0 ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError") {
+        if (userSignal?.aborted) {
+          throw new AbortError("Request aborted");
+        }
+        throw new TimeoutError("Request timed out");
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+      if (userSignal) {
+        userSignal.removeEventListener("abort", onUserAbort);
+      }
+    }
+  }
+  buildHeaders(method, options) {
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      Accept: "application/json"
+    };
+    if (method === "POST" || method === "PUT" || method === "PATCH") {
+      headers["Content-Type"] = "application/json";
+    }
+    if (options?.idempotencyKey) {
+      headers["Idempotency-Key"] = options.idempotencyKey;
+    }
+    if (this.agentId) headers["X-Agent-ID"] = this.agentId;
+    if (this.subject) headers["X-Nexus-Subject"] = this.subject;
+    if (this.zoneId) headers["X-Nexus-Zone-ID"] = this.zoneId;
+    if (options?.headers) {
+      for (const [key, value] of Object.entries(options.headers)) {
+        headers[key] = value;
+      }
+    }
+    return headers;
+  }
+  /**
+   * Map HTTP response to a typed error.
+   *
+   * Subclasses can override this to add domain-specific error mapping
+   * (e.g. 402 → InsufficientCreditsError in nexus-pay-ts).
+   */
+  async buildError(response) {
+    let message;
+    try {
+      const body = await response.json();
+      message = body.detail ?? `HTTP ${response.status}`;
+    } catch {
+      message = `HTTP ${response.status}`;
+    }
+    switch (response.status) {
+      case 401:
+        return new AuthenticationError(message);
+      case 403:
+        return new ForbiddenError(message);
+      case 404:
+        return new NotFoundError(message);
+      case 409:
+        return new ConflictError(message);
+      case 429: {
+        const retryAfterHeader = response.headers.get("Retry-After");
+        const retryAfter = retryAfterHeader ? parseInt(retryAfterHeader, 10) : void 0;
+        return new RateLimitError(
+          message,
+          Number.isNaN(retryAfter) ? void 0 : retryAfter
+        );
+      }
+      default:
+        if (response.status >= 500) {
+          return new ServerError(message, response.status);
+        }
+        return new NexusApiError(message, response.status, "api_error");
+    }
+  }
+  computeRetryDelay(attempt, lastError) {
+    if (lastError instanceof RateLimitError && lastError.retryAfter !== void 0) {
+      return lastError.retryAfter * 1e3;
+    }
+    const exponentialDelay = INITIAL_RETRY_DELAY * Math.pow(2, attempt - 1);
+    const cappedDelay = Math.min(exponentialDelay, MAX_RETRY_DELAY);
+    return Math.random() * cappedDelay;
+  }
+  // ===========================================================================
+  // Knowledge platform helpers (Issue #2930)
+  // ===========================================================================
+  /**
+   * List all aspect names attached to an entity.
+   */
+  async getAspects(urn) {
+    const result = await this.get(
+      `/api/v2/aspects/${encodeURIComponent(urn)}`
+    );
+    return result.aspects ?? [];
+  }
+  /**
+   * Get a specific aspect for an entity. Returns null if not found.
+   */
+  async getAspect(urn, name) {
+    try {
+      return await this.get(
+        `/api/v2/aspects/${encodeURIComponent(urn)}/${encodeURIComponent(name)}`
+      );
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get extracted schema for a data file. Returns null if no schema.
+   */
+  async getCatalogSchema(path) {
+    const encodedPath = encodeURIComponent(path.replace(/^\//, ""));
+    const result = await this.get(
+      `/api/v2/catalog/schema/${encodedPath}`
+    );
+    return result.schema ?? null;
+  }
+  /**
+   * Search for data files containing a specific column name.
+   */
+  async searchByColumn(column) {
+    const result = await this.get(
+      `/api/v2/catalog/search?column=${encodeURIComponent(column)}`
+    );
+    return result.results ?? [];
+  }
+  /**
+   * Replay metadata change log records.
+   */
+  async replayChanges(opts) {
+    const params = new URLSearchParams();
+    if (opts?.fromSequence !== void 0) params.set("from_sequence", String(opts.fromSequence));
+    if (opts?.entityUrn) params.set("entity_urn", opts.entityUrn);
+    if (opts?.limit !== void 0) params.set("limit", String(opts.limit));
+    const qs = params.toString();
+    return this.get(`/api/v2/ops/replay${qs ? `?${qs}` : ""}`);
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/sse-client.ts
+var DEFAULT_BUFFER_CAPACITY = 1e3;
+var DEFAULT_FLUSH_INTERVAL_MS = 100;
+var INITIAL_RECONNECT_DELAY_MS = 500;
+var MAX_RECONNECT_DELAY_MS = 3e4;
+var RingBuffer = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.buffer = new Array(capacity);
+  }
+  buffer;
+  head = 0;
+  count = 0;
+  /** Monotonically increasing counter of total items ever pushed (never wraps). */
+  _totalPushed = 0;
+  get size() {
+    return this.count;
+  }
+  /** Total number of items pushed since creation/clear (never decreases). */
+  get totalPushed() {
+    return this._totalPushed;
+  }
+  push(item) {
+    this.buffer[this.head] = item;
+    this.head = (this.head + 1) % this.capacity;
+    if (this.count < this.capacity) {
+      this.count++;
+    }
+    this._totalPushed++;
+  }
+  /** Return items in insertion order (oldest first). */
+  toArray() {
+    if (this.count === 0) return [];
+    const result = [];
+    const start = this.count < this.capacity ? 0 : this.head;
+    for (let i = 0; i < this.count; i++) {
+      const index = (start + i) % this.capacity;
+      result.push(this.buffer[index]);
+    }
+    return result;
+  }
+  /** Return the last N items (newest first becomes oldest first). */
+  lastN(n) {
+    if (n <= 0 || this.count === 0) return [];
+    const take = Math.min(n, this.count);
+    const all = this.toArray();
+    return all.slice(all.length - take);
+  }
+  clear() {
+    this.buffer.fill(void 0);
+    this.head = 0;
+    this.count = 0;
+    this._totalPushed = 0;
+  }
+};
+var SseClient = class {
+  baseUrl;
+  apiKey;
+  fetchFn;
+  buffer;
+  flushIntervalMs;
+  agentId;
+  subject;
+  zoneId;
+  abortController = null;
+  flushTimer = null;
+  reconnectAttempt = 0;
+  lastEventId;
+  connected = false;
+  eventHandler = null;
+  errorHandler = null;
+  reconnectHandler = null;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.apiKey = options.apiKey;
+    this.fetchFn = options.fetch ?? globalThis.fetch;
+    this.buffer = new RingBuffer(options.bufferCapacity ?? DEFAULT_BUFFER_CAPACITY);
+    this.flushIntervalMs = options.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
+    this.agentId = options.agentId;
+    this.subject = options.subject;
+    this.zoneId = options.zoneId;
+  }
+  onEvent(handler) {
+    this.eventHandler = handler;
+  }
+  onError(handler) {
+    this.errorHandler = handler;
+  }
+  onReconnect(handler) {
+    this.reconnectHandler = handler;
+  }
+  get isConnected() {
+    return this.connected;
+  }
+  async connect(path) {
+    this.disconnect();
+    this.abortController = new AbortController();
+    this.startFlushTimer();
+    await this.connectWithRetry(path);
+  }
+  disconnect() {
+    this.abortController?.abort();
+    this.abortController = null;
+    this.stopFlushTimer();
+    this.connected = false;
+    this.reconnectAttempt = 0;
+    this.lastFlushedTotal = 0;
+  }
+  getBufferedEvents() {
+    return this.buffer.toArray();
+  }
+  clearBuffer() {
+    this.buffer.clear();
+    this.lastFlushedTotal = 0;
+  }
+  // ===========================================================================
+  // Internal
+  // ===========================================================================
+  async connectWithRetry(path) {
+    while (this.abortController && !this.abortController.signal.aborted) {
+      try {
+        await this.streamEvents(path);
+      } catch (error) {
+        if (this.abortController?.signal.aborted) return;
+        this.connected = false;
+        this.reconnectAttempt++;
+        this.errorHandler?.(error instanceof Error ? error : new Error(String(error)));
+        this.reconnectHandler?.(this.reconnectAttempt);
+        const delay = this.computeReconnectDelay();
+        await sleep2(delay);
+      }
+    }
+  }
+  async streamEvents(path) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      Accept: "text/event-stream"
+    };
+    if (this.agentId) headers["X-Agent-ID"] = this.agentId;
+    if (this.subject) headers["X-Nexus-Subject"] = this.subject;
+    if (this.zoneId) headers["X-Nexus-Zone-ID"] = this.zoneId;
+    if (this.lastEventId) {
+      headers["Last-Event-ID"] = this.lastEventId;
+    }
+    const response = await this.fetchFn(url, {
+      headers,
+      signal: this.abortController?.signal
+    });
+    if (!response.ok) {
+      throw new Error(`SSE connection failed: HTTP ${response.status}`);
+    }
+    if (!response.body) {
+      throw new Error("SSE response has no body");
+    }
+    this.connected = true;
+    this.reconnectAttempt = 0;
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let partial = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        partial += decoder.decode(value, { stream: true });
+        const events = this.parseEvents(partial);
+        partial = events.remaining;
+        for (const event of events.parsed) {
+          this.buffer.push(event);
+          if (event.id) {
+            this.lastEventId = event.id;
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+      this.connected = false;
+    }
+  }
+  parseEvents(text) {
+    const parsed = [];
+    const blocks = text.split("\n\n");
+    const remaining = blocks.pop() ?? "";
+    for (const block of blocks) {
+      if (!block.trim()) continue;
+      let id;
+      let event = "message";
+      let data = "";
+      let retry;
+      for (const line of block.split("\n")) {
+        if (line.startsWith("id:")) {
+          id = line.slice(3).trim();
+        } else if (line.startsWith("event:")) {
+          event = line.slice(6).trim();
+        } else if (line.startsWith("data:")) {
+          data += (data ? "\n" : "") + line.slice(5).trim();
+        } else if (line.startsWith("retry:")) {
+          const val = parseInt(line.slice(6).trim(), 10);
+          if (!Number.isNaN(val)) retry = val;
+        }
+      }
+      if (data || event !== "message") {
+        parsed.push({ id, event, data, retry });
+      }
+    }
+    return { parsed, remaining };
+  }
+  /** Tracks total events flushed via the monotonic totalPushed counter. */
+  lastFlushedTotal = 0;
+  startFlushTimer() {
+    this.lastFlushedTotal = this.buffer.totalPushed;
+    this.flushTimer = setInterval(() => {
+      const currentTotal = this.buffer.totalPushed;
+      if (currentTotal > this.lastFlushedTotal) {
+        const newCount = currentTotal - this.lastFlushedTotal;
+        const newEvents = this.buffer.lastN(newCount);
+        this.lastFlushedTotal = currentTotal;
+        if (newEvents.length > 0) {
+          this.eventHandler?.(newEvents);
+        }
+      }
+    }, this.flushIntervalMs);
+  }
+  stopFlushTimer() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  computeReconnectDelay() {
+    const exponential = INITIAL_RECONNECT_DELAY_MS * Math.pow(2, this.reconnectAttempt - 1);
+    const capped = Math.min(exponential, MAX_RECONNECT_DELAY_MS);
+    return capped + Math.random() * capped * 0.1;
+  }
+};
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/config.ts
+var DEFAULT_BASE_URL2 = "http://localhost:2026";
+function resolveConfig(overrides) {
+  const yamlConfig = readYamlConfig();
+  const envUrl = readEnv("NEXUS_URL");
+  const envApiKey = readEnv("NEXUS_API_KEY");
+  return {
+    apiKey: overrides?.apiKey ?? yamlConfig.apiKey ?? envApiKey ?? "",
+    baseUrl: overrides?.baseUrl ?? yamlConfig.url ?? envUrl ?? DEFAULT_BASE_URL2,
+    timeout: overrides?.timeout,
+    maxRetries: overrides?.maxRetries,
+    fetch: overrides?.fetch,
+    transformKeys: overrides?.transformKeys,
+    agentId: overrides?.agentId ?? yamlConfig.agentId ?? readEnv("NEXUS_AGENT_ID"),
+    subject: overrides?.subject ?? readEnv("NEXUS_SUBJECT"),
+    zoneId: overrides?.zoneId ?? yamlConfig.zoneId ?? readEnv("NEXUS_ZONE_ID")
+  };
+}
+function readEnv(name) {
+  try {
+    return typeof process !== "undefined" ? process.env[name] : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readYamlConfig() {
+  try {
+    const fs = __require("fs");
+    const os = __require("os");
+    const path = __require("path");
+    const candidates = [];
+    let dir = path.resolve(".");
+    for (let i = 0; i < 20; i++) {
+      candidates.push(path.join(dir, "nexus.yaml"));
+      candidates.push(path.join(dir, "nexus.yml"));
+      try {
+        if (fs.existsSync(path.join(dir, ".git"))) break;
+      } catch {
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    candidates.push(path.join(os.homedir(), ".nexus", "config.yaml"));
+    for (const configPath of candidates) {
+      try {
+        const content = fs.readFileSync(configPath, "utf-8");
+        let url = extractYamlValue(content, "url");
+        const apiKey = extractYamlValue(content, "api_key");
+        const agentId = extractYamlValue(content, "agent_id");
+        const zoneId = extractYamlValue(content, "zone_id");
+        if (!url) {
+          const httpPort = extractIndentedYamlValue(content, "ports", "http");
+          if (httpPort) {
+            url = `http://localhost:${httpPort}`;
+          }
+        }
+        return {
+          url: url ?? void 0,
+          apiKey: apiKey ?? void 0,
+          agentId: agentId ?? void 0,
+          zoneId: zoneId ?? void 0
+        };
+      } catch {
+      }
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+function extractYamlValue(content, key) {
+  const regex = new RegExp(`^${key}:\\s*["']?([^"'\\n]+)["']?`, "m");
+  const match = regex.exec(content);
+  return match?.[1]?.trim() ?? null;
+}
+function extractIndentedYamlValue(content, parent, child) {
+  const regex = new RegExp(`^${parent}:\\s*\\n(?:[ ]{2}\\w+:[^\\n]*\\n)*?[ ]{2}${child}:\\s*["']?([^"'\\n]+)["']?`, "m");
+  const match = regex.exec(content);
+  return match?.[1]?.trim() ?? null;
+}
+
+export { AbortError, AuthenticationError, ConflictError, FetchClient, ForbiddenError, NetworkError, NexusApiError, NotFoundError, RateLimitError, RingBuffer, ServerError, SseClient, TimeoutError, camelToSnake, camelToSnakeKeys, resolveConfig, snakeToCamel, snakeToCamelKeys, transformKeys };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map