nixflex 0.1.0

package/README.md

@@ -0,0 +1,80 @@
+# Nixflex Node.js SDK
+
+Official Node.js SDK for the [Nixflex](https://nixflex.com) voice AI platform — AI phone agents, outbound campaigns, SMS, and web calls.
+
+```bash
+npm install nixflex
+```
+
+## Quickstart
+
+```js
+import Nixflex from 'nixflex';
+
+const client = new Nixflex({ apiKey: 'nxf_xxx:nxfs_xxx' });
+
+// Create an agent (every field has a sensible default)
+const agent = await client.agents.create({
+  name: 'Acme Dental Receptionist',
+  system_prompt: 'You are the friendly front-desk assistant at Acme Dental...',
+});
+
+// Attach a number you own (carrier inferred from credentials)
+await client.phoneNumbers.import({
+  phone_number: '+447446466847',
+  twilio_sid: process.env.TWILIO_SID,
+  twilio_token: process.env.TWILIO_TOKEN,
+  agent_id: agent.agent_id,
+});
+
+// Trigger an outbound AI call (fire-and-forget)
+const call = await client.calls.create({
+  agent_id: agent.agent_id,
+  to_number: '+447386172392',
+  prompt: 'Remind {patient_name} about their appointment on {time}.',
+  dynamic_vars: { patient_name: 'Sarah', time: 'Tuesday at 2pm' },
+});
+```
+
+## Resources
+
+| Resource | Methods |
+|---|---|
+| `client.agents` | `create` `list` `get` `update` `delete` `iter` |
+| `client.calls` | `create` (outbound) `list` `get` `iter` |
+| `client.campaigns` | `create` `launch` — voice batch campaigns with scheduling windows |
+| `client.phoneNumbers` | `import` `list` `update` `delete` `setMonitor` `getMonitor` `setWebCalls` `getWebCalls` |
+| `client.sms` | `send` + `campaigns.create/launch/list/get/delete` |
+| `client.keys` | `rotate` (Stripe-style: key_id stays, secret rotates) |
+| `client.usage` | `get` — minutes, calls, SMS, balance |
+| `client.webhooks` | `set` `get` `delete` — per-number post-call webhooks (2 slots) |
+| `Nixflex.createKey()` | static — signup without auth |
+
+## Errors — typed, catchable by class
+
+```js
+import { NixflexRateLimitError, NixflexPaymentRequiredError } from 'nixflex';
+
+try {
+  await client.calls.create({ ... });
+} catch (e) {
+  if (e instanceof NixflexRateLimitError) {
+    console.log(`Rate limited — retry in ${e.retryAfterSeconds}s`);
+  } else if (e instanceof NixflexPaymentRequiredError) {
+    console.log('Top up your balance');
+  }
+  // Every error carries: status, code, type, message, docUrl, details, requestId
+}
+```
+
+## Built in
+
+- **Automatic retries** — 429s retried honouring `Retry-After`; network failures retried; POST never blind-retries a 5xx (no double dials)
+- **Pagination iterators** — `for await (const call of client.calls.iter()) { ... }`
+- **TypeScript types for every request and response** — generated from the [API docs](https://docs.nixflex.com)
+- **Timeouts + AbortSignal support** per client or per request
+- **Zero runtime dependencies** — native fetch, Node 18+
+
+## Docs
+
+Full API reference: **https://docs.nixflex.com**

package/dist/index.cjs

@@ -0,0 +1,516 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Nixflex: () => Nixflex,
+  NixflexAuthenticationError: () => NixflexAuthenticationError,
+  NixflexConnectionError: () => NixflexConnectionError,
+  NixflexError: () => NixflexError,
+  NixflexInvalidRequestError: () => NixflexInvalidRequestError,
+  NixflexNotFoundError: () => NixflexNotFoundError,
+  NixflexPaymentRequiredError: () => NixflexPaymentRequiredError,
+  NixflexRateLimitError: () => NixflexRateLimitError,
+  NixflexServerError: () => NixflexServerError,
+  default: () => index_default,
+  errorFromResponse: () => errorFromResponse
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var NixflexError = class extends Error {
+  /** HTTP status of the failed response (0 for network/timeout failures). */
+  status;
+  /** Machine-readable error code, e.g. 'invalid_json', 'rate_limit_exceeded'. */
+  code;
+  /** Error category from the API, e.g. 'invalid_request', 'rate_limit'. */
+  type;
+  /** Link to the error's documentation page. */
+  docUrl;
+  /** Structured extra info the API attached to this error. */
+  details;
+  /** The x-railway-request-id (or similar) header when present - quote it to support. */
+  requestId;
+  constructor(status, body, requestId, fallbackMessage) {
+    const e = body == null ? void 0 : body.error;
+    super((e == null ? void 0 : e.message) || fallbackMessage || `Nixflex API error (HTTP ${status})`);
+    this.name = "NixflexError";
+    this.status = status;
+    this.code = (e == null ? void 0 : e.code) || "unknown_error";
+    this.type = (e == null ? void 0 : e.type) || "error";
+    this.docUrl = e == null ? void 0 : e.doc_url;
+    this.details = (e == null ? void 0 : e.details) || {};
+    this.requestId = requestId;
+  }
+};
+var NixflexAuthenticationError = class extends NixflexError {
+  constructor(...args) {
+    super(...args);
+    this.name = "NixflexAuthenticationError";
+  }
+};
+var NixflexPaymentRequiredError = class extends NixflexError {
+  constructor(...args) {
+    super(...args);
+    this.name = "NixflexPaymentRequiredError";
+  }
+};
+var NixflexNotFoundError = class extends NixflexError {
+  constructor(...args) {
+    super(...args);
+    this.name = "NixflexNotFoundError";
+  }
+};
+var NixflexRateLimitError = class extends NixflexError {
+  retryAfterSeconds;
+  constructor(status, body, requestId, retryAfterSeconds) {
+    super(status, body, requestId);
+    this.name = "NixflexRateLimitError";
+    this.retryAfterSeconds = retryAfterSeconds;
+  }
+};
+var NixflexInvalidRequestError = class extends NixflexError {
+  constructor(...args) {
+    super(...args);
+    this.name = "NixflexInvalidRequestError";
+  }
+};
+var NixflexServerError = class extends NixflexError {
+  constructor(...args) {
+    super(...args);
+    this.name = "NixflexServerError";
+  }
+};
+var NixflexConnectionError = class extends NixflexError {
+  constructor(message) {
+    super(0, null, void 0, message);
+    this.name = "NixflexConnectionError";
+  }
+};
+function errorFromResponse(status, body, requestId, retryAfterSeconds) {
+  if (status === 401) return new NixflexAuthenticationError(status, body, requestId);
+  if (status === 402) return new NixflexPaymentRequiredError(status, body, requestId);
+  if (status === 404) return new NixflexNotFoundError(status, body, requestId);
+  if (status === 429) return new NixflexRateLimitError(status, body, requestId, retryAfterSeconds);
+  if (status === 400 || status === 422) return new NixflexInvalidRequestError(status, body, requestId);
+  if (status >= 500) return new NixflexServerError(status, body, requestId);
+  return new NixflexError(status, body, requestId);
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.nixflex.com";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var SDK_VERSION = "0.1.0";
+var HttpClient = class {
+  apiKey;
+  baseUrl;
+  timeoutMs;
+  maxRetries;
+  constructor(opts) {
+    if (!opts || typeof opts.apiKey !== "string" || !opts.apiKey.includes(":")) {
+      throw new Error(
+        'Nixflex: apiKey is required in the form "key_id:key_secret" (both parts, joined by a colon). Find yours at https://dashboard.nixflex.com under API Keys.'
+      );
+    }
+    this.apiKey = opts.apiKey;
+    this.baseUrl = (opts.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.maxRetries = opts.maxRetries ?? 1;
+  }
+  async request(method, path, body, query, reqOpts) {
+    const url = new URL(this.baseUrl + "/v1" + path);
+    if (query) {
+      for (const [k, v] of Object.entries(query)) {
+        if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
+      }
+    }
+    const isIdempotent = method === "GET" || method === "DELETE";
+    let attempt = 0;
+    while (true) {
+      attempt++;
+      let res;
+      try {
+        res = await this.fetchWithTimeout(url.toString(), method, body, reqOpts);
+      } catch (err) {
+        if (attempt <= this.maxRetries) {
+          await sleep(300 * attempt);
+          continue;
+        }
+        throw new NixflexConnectionError(
+          `Could not reach the Nixflex API (${(err == null ? void 0 : err.message) || "network error"}). Check connectivity and https://nixflex.com/status`
+        );
+      }
+      if (res.ok) {
+        if (res.status === 204) return void 0;
+        return await res.json();
+      }
+      const requestId = res.headers.get("x-railway-request-id") || void 0;
+      const retryAfter = parseInt(res.headers.get("retry-after") || "0", 10) || 0;
+      let errBody = null;
+      try {
+        errBody = await res.json();
+      } catch {
+      }
+      const retryable429 = res.status === 429;
+      const retryable5xx = res.status >= 500 && isIdempotent;
+      if ((retryable429 || retryable5xx) && attempt <= this.maxRetries) {
+        const waitMs = retryable429 ? Math.min(retryAfter, 30) * 1e3 || 1e3 : 500 * attempt;
+        await sleep(waitMs);
+        continue;
+      }
+      throw errorFromResponse(res.status, errBody, requestId, retryAfter);
+    }
+  }
+  async fetchWithTimeout(url, method, body, reqOpts) {
+    const controller = new AbortController();
+    const timeoutMs = (reqOpts == null ? void 0 : reqOpts.timeoutMs) ?? this.timeoutMs;
+    const timer = setTimeout(() => controller.abort(new Error(`timeout after ${timeoutMs}ms`)), timeoutMs);
+    if (reqOpts == null ? void 0 : reqOpts.signal) {
+      if (reqOpts.signal.aborted) controller.abort(reqOpts.signal.reason);
+      else reqOpts.signal.addEventListener("abort", () => controller.abort(reqOpts.signal.reason), { once: true });
+    }
+    try {
+      return await fetch(url, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json",
+          "User-Agent": `nixflex-node/${SDK_VERSION}`
+        },
+        body: body === void 0 ? void 0 : JSON.stringify(body),
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/resources/agents.ts
+var Agents = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Create an agent. Every field has a sensible default - `{ name }` alone works.
+   * The agent is immediately usable for numbers and outbound calls. */
+  create(params = {}, opts) {
+    return this.http.request("POST", "/agents", params, void 0, opts);
+  }
+  /** List active agents, newest first. Default 100, hard cap 200 per page. */
+  list(params = {}, opts) {
+    return this.http.request("GET", "/agents", void 0, { limit: params.limit, offset: params.offset }, opts);
+  }
+  /** Iterate ALL agents across pages: `for await (const a of client.agents.iter()) { ... }` */
+  async *iter(pageSize = 100, opts) {
+    let offset = 0;
+    while (true) {
+      const page = await this.list({ limit: pageSize, offset }, opts);
+      for (const item of page) yield item;
+      if (page.length < pageSize) return;
+      offset += page.length;
+    }
+  }
+  /** Fetch one agent with full configuration. Throws NixflexNotFoundError if the ID is not yours. */
+  get(agentId, opts) {
+    return this.http.request("GET", `/agents/${encodeURIComponent(agentId)}`, void 0, void 0, opts);
+  }
+  /** Update an agent. Send ONLY the fields you want to change - omitted fields
+   * keep their values. Active calls are unaffected; new calls use the new config.
+   * Unknown field names return 200 and change nothing - check spelling. */
+  update(agentId, params, opts) {
+    return this.http.request("PUT", `/agents/${encodeURIComponent(agentId)}`, params, void 0, opts);
+  }
+  /** PERMANENTLY delete an agent. Attached numbers detach and stop routing;
+   * historical calls stay accessible. To disable without losing setup, use
+   * update(agentId, { is_active: false }) instead. */
+  delete(agentId, opts) {
+    return this.http.request("DELETE", `/agents/${encodeURIComponent(agentId)}`, void 0, void 0, opts);
+  }
+};
+
+// src/resources/calls.ts
+var Calls = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Trigger an outbound AI call. FIRE-AND-FORGET: returns immediately with a
+   * call_id; ringing, conversation and ending happen asynchronously. Set a
+   * webhook_url on the agent or number to receive call.completed when it ends.
+   * The dialling number must be OUTBOUND-ENABLED (inbound working does not
+   * mean outbound works - separate switches). */
+  create(params, opts) {
+    return this.http.request("POST", "/calls/outbound", params, void 0, opts);
+  }
+  /** List calls, newest first. Default 50, hard cap 200. The response is a
+   * bare array with no total - page until you get fewer rows than you asked
+   * for (or use iter()). Call data is retained 90 days. */
+  list(params = {}, opts) {
+    return this.http.request("GET", "/calls", void 0, { limit: params.limit, offset: params.offset }, opts);
+  }
+  /** Iterate ALL calls across pages: `for await (const c of client.calls.iter()) { ... }` */
+  async *iter(pageSize = 100, opts) {
+    let offset = 0;
+    while (true) {
+      const page = await this.list({ limit: pageSize, offset }, opts);
+      for (const item of page) yield item;
+      if (page.length < pageSize) return;
+      offset += page.length;
+    }
+  }
+  /** Fetch one call: transcript, recording URL, post-call analysis. Note:
+   * duration_ms is time CONNECTED (what you are billed on) - ring time is
+   * excluded, so it will not equal end_timestamp - start_timestamp on
+   * outbound calls. */
+  get(callId, opts) {
+    return this.http.request("GET", `/calls/${encodeURIComponent(callId)}`, void 0, void 0, opts);
+  }
+};
+var Campaigns = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Create a batch campaign - many outbound calls under one campaign_id.
+   * schedule_type 'now' launches immediately; 'schedule' waits for
+   * scheduled_date and fires INSIDE the calling window in the campaign's
+   * timezone (yours > the agent's > Europe/London). Overnight windows
+   * supported. One campaign = one timezone - split multi-country lists. */
+  create(params, opts) {
+    return this.http.request("POST", "/calls/batch", params, void 0, opts);
+  }
+  /** Launch a scheduled campaign immediately, overriding its schedule.
+   * Already running = no-op returning current status. */
+  launch(campaignId, opts) {
+    return this.http.request("POST", `/calls/batch/${encodeURIComponent(campaignId)}/launch`, void 0, void 0, opts);
+  }
+};
+
+// src/resources/stage3.ts
+function enc(phoneNumber) {
+  return encodeURIComponent(phoneNumber);
+}
+var PhoneNumbers = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Attach a number you already own. Carrier inferred from credentials
+   * (twilio_sid+twilio_token OR telnyx_api_key+telnyx_connection_id).
+   * WARNING: Twilio import REPLACES the number's existing webhooks - another
+   * system using this number stops receiving calls and SMS. */
+  import(params, opts) {
+    return this.http.request("POST", "/phone-numbers", params, void 0, opts);
+  }
+  /** All numbers on your account (optionally one agent's), newest first.
+   * Not paginated - returns up to 1,000; filter by agent_id above that. */
+  list(params = {}, opts) {
+    return this.http.request("GET", "/phone-numbers", void 0, { agent_id: params.agent_id }, opts);
+  }
+  /** Update per-number settings. Send ONLY what changes (empty body is
+   * rejected). null clears/inherits - see each field's JSDoc; speaking_rate
+   * null INHERITS the agent's speed (send 1, not null, to force normal). */
+  update(phoneNumber, params, opts) {
+    return this.http.request("PATCH", `/phone-numbers/${enc(phoneNumber)}`, params, void 0, opts);
+  }
+  /** Disconnect from Nixflex (clears carrier webhooks + our record). Does NOT
+   * release the number from your carrier - carrier billing continues until
+   * you release it in Twilio/Telnyx yourself. Reversible by re-importing. */
+  delete(phoneNumber, opts) {
+    return this.http.request("DELETE", `/phone-numbers/${enc(phoneNumber)}`, void 0, void 0, opts);
+  }
+  /** Turn live call monitoring on/off for a number (off by default).
+   * NOTE: enabling bills that number's inbound calls at $0.09/min. */
+  setMonitor(phoneNumber, enabled, opts) {
+    return this.http.request("PUT", `/integrations/monitor/number/${enc(phoneNumber)}`, { enabled }, void 0, opts);
+  }
+  /** Current monitoring state for a number. */
+  getMonitor(phoneNumber, opts) {
+    return this.http.request("GET", `/integrations/monitor/number/${enc(phoneNumber)}`, void 0, void 0, opts);
+  }
+  /** Enable/disable browser (web) calls for a number (off by default).
+   * NOTE: enabling bills that number's calls at $0.09/min (same rule as
+   * Live Monitor - either on means 0.09, both on is still 0.09). */
+  setWebCalls(phoneNumber, enabled, opts) {
+    return this.http.request("PUT", `/integrations/web-calls/number/${enc(phoneNumber)}`, { enabled }, void 0, opts);
+  }
+  /** Current web-calls state for a number. */
+  getWebCalls(phoneNumber, opts) {
+    return this.http.request("GET", `/integrations/web-calls/number/${enc(phoneNumber)}`, void 0, void 0, opts);
+  }
+};
+var SmsCampaigns = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Create a one-time SMS broadcast ({{variable}} templating per recipient,
+   * up to 10,000 recipients). Requires a TWILIO from_number - Telnyx numbers
+   * are rejected at create (single sends support both carriers). */
+  create(params, opts) {
+    return this.http.request("POST", "/sms/campaigns", params, void 0, opts);
+  }
+  /** Launch a draft/scheduled campaign immediately. */
+  launch(campaignId, opts) {
+    return this.http.request("POST", `/sms/campaigns/${encodeURIComponent(campaignId)}/launch`, void 0, void 0, opts);
+  }
+  /** All campaigns, newest first, with live-computed delivery counts. */
+  list(params = {}, opts) {
+    return this.http.request("GET", "/sms/campaigns", void 0, { status: params.status, limit: params.limit }, opts);
+  }
+  /** One campaign with per-recipient statuses. Twilio 'sent' (handed to
+   * carrier, never confirmed on the handset) counts as FAILED, not delivered. */
+  get(campaignId, opts) {
+    return this.http.request("GET", `/sms/campaigns/${encodeURIComponent(campaignId)}`, void 0, void 0, opts);
+  }
+  /** Cancel a scheduled/running campaign. Already-sent messages cannot be
+   * recalled; cancelled_count = pending recipients that will not be messaged. */
+  delete(campaignId, opts) {
+    return this.http.request("DELETE", `/sms/campaigns/${encodeURIComponent(campaignId)}`, void 0, void 0, opts);
+  }
+};
+var Sms = class {
+  constructor(http) {
+    this.http = http;
+    this.campaigns = new SmsCampaigns(http);
+  }
+  http;
+  /** SMS campaigns - one-time bulk broadcasts. */
+  campaigns;
+  /** Send a single SMS from one of your numbers (both carriers). NOTE: this
+   * endpoint uses `to` - NOT to_number (that is the outbound-call field).
+   * Replies are answered automatically by the agent's prompt. */
+  send(params, opts) {
+    return this.http.request("POST", "/sms", params, void 0, opts);
+  }
+};
+var Keys = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Rotate the key SECRET (key_id stays stable - the Stripe model). The old
+   * secret stops working THE INSTANT this returns; the new one is shown ONCE.
+   * Update every deployed app before rotating in production. */
+  rotate(opts) {
+    return this.http.request("POST", "/keys/rotate", void 0, void 0, opts);
+  }
+};
+var UsageResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Usage + balance: calls, minutes, SMS, credit. minutes is fractional;
+   * cost_usd excludes carrier charges (Twilio/Telnyx bill you directly). */
+  get(opts) {
+    return this.http.request("GET", "/usage", void 0, void 0, opts);
+  }
+};
+var Webhooks = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Point a number's post-call events at your HTTPS endpoint.
+   * slot 2 = the second destination (webhook2). */
+  set(phoneNumber, url, slot = 1, opts) {
+    const base = slot === 2 ? "webhook2" : "webhook";
+    return this.http.request("PUT", `/integrations/${base}/number/${encodeURIComponent(phoneNumber)}`, { url }, void 0, opts);
+  }
+  /** Read the webhook configured on a number. */
+  get(phoneNumber, slot = 1, opts) {
+    const base = slot === 2 ? "webhook2" : "webhook";
+    return this.http.request("GET", `/integrations/${base}/number/${encodeURIComponent(phoneNumber)}`, void 0, void 0, opts);
+  }
+  /** Remove the webhook from a number. */
+  delete(phoneNumber, slot = 1, opts) {
+    const base = slot === 2 ? "webhook2" : "webhook";
+    return this.http.request("DELETE", `/integrations/${base}/number/${encodeURIComponent(phoneNumber)}`, void 0, void 0, opts);
+  }
+};
+
+// src/index.ts
+var Nixflex = class {
+  /** AI agents - create, list, get, update, delete. */
+  agents;
+  /** Calls - trigger outbound, list history, fetch transcripts + analysis. */
+  calls;
+  /** Voice batch campaigns - many calls under one campaign, scheduling windows. */
+  campaigns;
+  /** Phone numbers - import (Twilio/Telnyx), settings, monitor + web-calls toggles. */
+  phoneNumbers;
+  /** SMS - single sends + bulk campaigns. */
+  sms;
+  /** API key management - rotate the secret. */
+  keys;
+  /** Usage + balance. */
+  usage;
+  /** Per-number post-call webhook configuration. */
+  webhooks;
+  constructor(options) {
+    const http = new HttpClient(options);
+    this.agents = new Agents(http);
+    this.calls = new Calls(http);
+    this.campaigns = new Campaigns(http);
+    this.phoneNumbers = new PhoneNumbers(http);
+    this.sms = new Sms(http);
+    this.keys = new Keys(http);
+    this.usage = new UsageResource(http);
+    this.webhooks = new Webhooks(http);
+  }
+  /** Create a brand-new API key (unauthenticated signup endpoint - most
+   * developers use the dashboard instead). The key_secret is shown ONCE.
+   * Rate-limited per IP to prevent abuse. */
+  static async createKey(params = {}, baseUrl = "https://api.nixflex.com") {
+    const res = await fetch(baseUrl.replace(/\/+$/, "") + "/v1/keys", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(params)
+    });
+    const body = await res.json();
+    if (!res.ok) {
+      throw errorFromResponse(
+        res.status,
+        body,
+        res.headers.get("x-railway-request-id") || void 0,
+        parseInt(res.headers.get("retry-after") || "0", 10) || 0
+      );
+    }
+    return body;
+  }
+};
+var index_default = Nixflex;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Nixflex,
+  NixflexAuthenticationError,
+  NixflexConnectionError,
+  NixflexError,
+  NixflexInvalidRequestError,
+  NixflexNotFoundError,
+  NixflexPaymentRequiredError,
+  NixflexRateLimitError,
+  NixflexServerError,
+  errorFromResponse
+});