@nopaque/sdk 0.1.1

package/dist/index.mjs

@@ -0,0 +1,1149 @@
+// src/errors.ts
+var NopaqueError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+  }
+};
+var NopaqueConfigError = class extends NopaqueError {
+};
+var NopaqueTimeoutError = class extends NopaqueError {
+};
+var APIConnectionError = class extends NopaqueError {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+  }
+};
+var APITimeoutError = class extends NopaqueError {
+};
+var NopaqueAPIError = class extends NopaqueError {
+  status;
+  code;
+  details;
+  requestId;
+  response;
+  constructor(init) {
+    super(init.message ?? `HTTP ${init.status}`);
+    this.status = init.status;
+    this.code = init.code ?? null;
+    this.details = init.details ?? null;
+    this.requestId = init.requestId ?? null;
+    this.response = init.response ?? null;
+  }
+};
+var ValidationError = class extends NopaqueAPIError {
+};
+var AuthenticationError = class extends NopaqueAPIError {
+};
+var PermissionError = class extends NopaqueAPIError {
+};
+var NotFoundError = class extends NopaqueAPIError {
+};
+var ConflictError = class extends NopaqueAPIError {
+};
+var ServerError = class extends NopaqueAPIError {
+};
+var RateLimitError = class extends NopaqueAPIError {
+  retryAfter;
+  constructor(init) {
+    super(init);
+    this.retryAfter = init.retryAfter ?? null;
+  }
+};
+var STATUS_MAP = {
+  400: ValidationError,
+  401: AuthenticationError,
+  403: PermissionError,
+  404: NotFoundError,
+  409: ConflictError,
+  429: RateLimitError
+};
+function classifyStatus(status) {
+  const specific = STATUS_MAP[status];
+  if (specific) return specific;
+  if (status >= 500 && status < 600) return ServerError;
+  return NopaqueAPIError;
+}
+
+// src/config.ts
+var DEFAULT_BASE_URL = "https://api.nopaque.co.uk";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var DEFAULT_MAX_RETRIES = 3;
+function resolveConfig(opts) {
+  const apiKey = opts.apiKey ?? process.env.NOPAQUE_API_KEY ?? "";
+  if (!apiKey) {
+    throw new NopaqueConfigError(
+      "No API key provided. Pass apiKey in the constructor or set NOPAQUE_API_KEY."
+    );
+  }
+  const baseUrl = (opts.baseUrl ?? process.env.NOPAQUE_BASE_URL ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+  return {
+    apiKey,
+    baseUrl,
+    timeout: opts.timeout ?? DEFAULT_TIMEOUT_MS,
+    maxRetries: opts.maxRetries ?? DEFAULT_MAX_RETRIES,
+    defaultHeaders: opts.defaultHeaders ?? {},
+    onRetry: opts.onRetry,
+    fetch: opts.fetch ?? globalThis.fetch.bind(globalThis)
+  };
+}
+
+// src/version.ts
+var VERSION = true ? "0.1.1" : "0.0.0-dev";
+
+// src/userAgent.ts
+function composeUserAgent() {
+  const nodeVersion = typeof process !== "undefined" ? process.version : "unknown";
+  return `nopaque-node/${VERSION} (node/${nodeVersion})`;
+}
+
+// src/requestOptions.ts
+function mergeOptions(base, override) {
+  if (!base) return override ?? {};
+  if (!override) return base;
+  return {
+    ...base,
+    ...override,
+    headers: { ...base.headers ?? {}, ...override.headers ?? {} }
+  };
+}
+
+// src/retry.ts
+var DEFAULTS = { base: 500, cap: 8e3, jitter: 1.5 };
+function computeBackoff(attempt, p = {}) {
+  const { base, cap, jitter } = { ...DEFAULTS, ...p };
+  const raw = Math.min(cap, base * 2 ** attempt);
+  const mul = 0.5 + Math.random() * (jitter - 0.5);
+  return Math.round(raw * mul);
+}
+function delayFor(args) {
+  const { attempt, error, ...p } = args;
+  if (error instanceof RateLimitError && error.retryAfter !== null) {
+    return Math.round(error.retryAfter * 1e3);
+  }
+  return computeBackoff(attempt, p);
+}
+function shouldRetry({ method, error, beforeSend }) {
+  const m = method.toUpperCase();
+  if (error instanceof RateLimitError) return true;
+  if (m === "POST") {
+    return error instanceof APIConnectionError && beforeSend;
+  }
+  if (error instanceof APIConnectionError || error instanceof APITimeoutError || error instanceof ServerError) {
+    return true;
+  }
+  if (error instanceof NopaqueAPIError) return false;
+  return false;
+}
+
+// src/transport.ts
+var Transport = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  async request(method, path, { params, body, requestOptions } = {}) {
+    const url = this.buildUrl(path, params);
+    const headers = this.buildHeaders(requestOptions);
+    const merged = mergeOptions(void 0, requestOptions);
+    const timeout = merged.timeout ?? this.config.timeout;
+    const maxRetries = merged.maxRetries ?? this.config.maxRetries;
+    let attempt = 0;
+    while (true) {
+      let beforeSend = true;
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeout);
+      const combinedSignal = mergeAbortSignals([controller.signal, merged.signal]);
+      let err = null;
+      let response = null;
+      try {
+        response = await this.config.fetch(url, {
+          method,
+          headers,
+          body: body === void 0 ? void 0 : JSON.stringify(body),
+          signal: combinedSignal
+        });
+        beforeSend = false;
+        if (!response.ok) {
+          err = await classifyResponse(response);
+        }
+      } catch (fetchErr) {
+        if (fetchErr.name === "AbortError") {
+          err = new APITimeoutError(`request timed out after ${timeout}ms`);
+        } else {
+          err = new APIConnectionError(
+            `fetch failed: ${fetchErr.message ?? "unknown"}`,
+            fetchErr
+          );
+        }
+      } finally {
+        clearTimeout(timer);
+      }
+      if (!err) {
+        if (response.status === 204) return void 0;
+        const ct = response.headers.get("content-type") ?? "";
+        if (!ct.includes("application/json")) return void 0;
+        return await response.json();
+      }
+      if (attempt >= maxRetries) throw err;
+      if (!shouldRetry({ method, error: err, beforeSend })) throw err;
+      const delay = delayFor({ attempt, error: err });
+      if (this.config.onRetry) {
+        try {
+          this.config.onRetry(attempt, err, delay);
+        } catch {
+        }
+      }
+      await new Promise((r) => setTimeout(r, delay));
+      attempt++;
+    }
+  }
+  buildUrl(path, params) {
+    const normalized = path.startsWith("/") ? path : `/${path}`;
+    const url = new URL(`${this.config.baseUrl}${normalized}`);
+    if (params) {
+      for (const [k, v] of Object.entries(params)) {
+        if (v === void 0 || v === null) continue;
+        url.searchParams.set(k, String(v));
+      }
+    }
+    return url.toString();
+  }
+  buildHeaders(options) {
+    const h = new Headers({
+      "x-api-key": this.config.apiKey,
+      "user-agent": composeUserAgent(),
+      "accept": "application/json"
+    });
+    for (const [k, v] of Object.entries(this.config.defaultHeaders)) h.set(k, v);
+    if (options?.headers) {
+      for (const [k, v] of Object.entries(options.headers)) h.set(k, v);
+    }
+    return h;
+  }
+};
+async function classifyResponse(response) {
+  let body = null;
+  try {
+    body = await response.clone().json();
+  } catch {
+    body = null;
+  }
+  const bodyObj = body && typeof body === "object" ? body : {};
+  const message = typeof bodyObj.error === "string" ? bodyObj.error : `HTTP ${response.status}`;
+  const code = typeof bodyObj.code === "string" ? bodyObj.code : null;
+  const details = bodyObj.details ?? null;
+  const requestId = response.headers.get("x-request-id");
+  const Cls = classifyStatus(response.status);
+  if (Cls === RateLimitError) {
+    const raw = response.headers.get("retry-after");
+    const retryAfter = raw !== null ? Number.parseFloat(raw) : null;
+    return new RateLimitError({
+      status: response.status,
+      code,
+      message,
+      details,
+      requestId,
+      response,
+      retryAfter: Number.isFinite(retryAfter) ? retryAfter : null
+    });
+  }
+  return new Cls({
+    status: response.status,
+    code,
+    message,
+    details,
+    requestId,
+    response
+  });
+}
+function mergeAbortSignals(signals) {
+  const valid = signals.filter((s) => !!s);
+  if (valid.length === 1) return valid[0];
+  if (valid.length === 0) return new AbortController().signal;
+  const ctrl = new AbortController();
+  for (const s of valid) {
+    if (s.aborted) {
+      ctrl.abort(s.reason);
+      return ctrl.signal;
+    }
+    s.addEventListener("abort", () => ctrl.abort(s.reason), { once: true });
+  }
+  return ctrl.signal;
+}
+
+// src/resources/audio.ts
+import { promises as fsp2 } from "fs";
+
+// src/resource.ts
+var Resource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+};
+
+// src/pagination.ts
+var Page = class {
+  constructor(items, nextToken) {
+    this.items = items;
+    this.nextToken = nextToken;
+  }
+  items;
+  nextToken;
+};
+var Paginator = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async *[Symbol.asyncIterator]() {
+    const limit = this.options.params.limit;
+    const params = { ...this.options.params };
+    const key = this.options.itemsKey;
+    let yielded = 0;
+    while (true) {
+      const page = await this.options.fetchPage(params);
+      const rawItems = (key ? page[key] : void 0) ?? page.items ?? [];
+      const items = rawItems;
+      for (const raw of items) {
+        const item = this.options.mapItem ? this.options.mapItem(raw) : raw;
+        yield item;
+        yielded++;
+        if (limit !== void 0 && yielded >= limit) return;
+      }
+      const nextToken = page.nextToken;
+      if (!nextToken) return;
+      params.nextToken = nextToken;
+    }
+  }
+};
+
+// src/s3.ts
+import { promises as fsp } from "fs";
+import { basename } from "path";
+async function readBytes(input) {
+  if (typeof input === "string") {
+    const buf = await fsp.readFile(input);
+    return { bytes: new Uint8Array(buf), inferredName: basename(input) };
+  }
+  if (input instanceof Uint8Array) {
+    return { bytes: input, inferredName: null };
+  }
+  if (typeof Blob !== "undefined" && input instanceof Blob) {
+    const buf = await input.arrayBuffer();
+    const name = input.name ?? null;
+    return { bytes: new Uint8Array(buf), inferredName: name };
+  }
+  if (typeof input.getReader === "function") {
+    const reader = input.getReader();
+    const chunks = [];
+    let total = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      total += value.byteLength;
+    }
+    const out = new Uint8Array(total);
+    let off = 0;
+    for (const c of chunks) {
+      out.set(c, off);
+      off += c.byteLength;
+    }
+    return { bytes: out, inferredName: null };
+  }
+  if (typeof input.on === "function") {
+    const chunks = [];
+    for await (const chunk of input) {
+      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    }
+    const buf = Buffer.concat(chunks);
+    return { bytes: new Uint8Array(buf), inferredName: null };
+  }
+  throw new TypeError("unsupported file input");
+}
+var EXTENSION_MAP = {
+  ".wav": "audio/wav",
+  ".mp3": "audio/mpeg",
+  ".mp4": "audio/mp4",
+  ".m4a": "audio/mp4",
+  ".ogg": "audio/ogg",
+  ".flac": "audio/flac",
+  ".webm": "audio/webm"
+};
+function sniffContentType(name) {
+  if (!name) return "application/octet-stream";
+  const dot = name.lastIndexOf(".");
+  const ext = dot >= 0 ? name.slice(dot).toLowerCase() : "";
+  return EXTENSION_MAP[ext] ?? "application/octet-stream";
+}
+async function s3Put(url, data, { contentType, fetch }) {
+  let resp;
+  try {
+    resp = await fetch(url, {
+      method: "PUT",
+      body: data,
+      headers: { "content-type": contentType }
+    });
+  } catch (err) {
+    throw new APIConnectionError(`S3 PUT failed: ${err.message}`, err);
+  }
+  if (resp.status >= 400) {
+    const text = await resp.text().catch(() => "");
+    throw new APIConnectionError(`S3 PUT returned ${resp.status}: ${text.slice(0, 200)}`);
+  }
+}
+async function s3Get(url, { fetch }) {
+  let resp;
+  try {
+    resp = await fetch(url);
+  } catch (err) {
+    throw new APIConnectionError(`S3 GET failed: ${err.message}`, err);
+  }
+  if (resp.status >= 400) {
+    const text = await resp.text().catch(() => "");
+    throw new APIConnectionError(`S3 GET returned ${resp.status}: ${text.slice(0, 200)}`);
+  }
+  return new Uint8Array(await resp.arrayBuffer());
+}
+
+// src/resources/audio.ts
+var AudioResource = class extends Resource {
+  list(params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => await this.transport.request("GET", "/audio", {
+        params: p,
+        requestOptions
+      }),
+      params: { ...params },
+      itemsKey: "audioFiles"
+    });
+  }
+  async listPage(params = {}, requestOptions) {
+    const raw = await this.transport.request("GET", "/audio", { params, requestOptions });
+    return new Page(raw.audioFiles ?? raw.items ?? [], raw.nextToken ?? null);
+  }
+  async get(audioId, requestOptions) {
+    return await this.transport.request("GET", `/audio/${audioId}`, { requestOptions });
+  }
+  async delete(audioId, requestOptions) {
+    await this.transport.request("DELETE", `/audio/${audioId}`, { requestOptions });
+  }
+  async createUploadUrl(body, requestOptions) {
+    return await this.transport.request("POST", "/audio/upload-url", {
+      body,
+      requestOptions
+    });
+  }
+  async createDownloadUrl(audioId, requestOptions) {
+    return await this.transport.request("GET", "/audio/download-url", {
+      params: { audioId },
+      requestOptions
+    });
+  }
+  async upload(input, requestOptions) {
+    const { bytes, inferredName } = await readBytes(input.file);
+    const resolvedName = input.name ?? inferredName ?? "upload.bin";
+    const resolvedType = input.contentType ?? sniffContentType(resolvedName);
+    const presign = await this.createUploadUrl(
+      { fileName: resolvedName, contentType: resolvedType },
+      requestOptions
+    );
+    await s3Put(presign.uploadUrl, bytes, {
+      contentType: resolvedType,
+      fetch: this.transport.config.fetch
+    });
+    return await this.get(presign.audioId, requestOptions);
+  }
+  async download(audioId, options, requestOptions) {
+    const presign = await this.createDownloadUrl(audioId, requestOptions);
+    const bytes = await s3Get(presign.downloadUrl, { fetch: this.transport.config.fetch });
+    if (options?.to) {
+      await fsp2.writeFile(options.to, bytes);
+      return;
+    }
+    return bytes;
+  }
+};
+
+// src/polling.ts
+var DEFAULT_BASE = 5e3;
+var DEFAULT_CAP = 15e3;
+function pollIntervalCurve(step, { base = DEFAULT_BASE, cap = DEFAULT_CAP } = {}) {
+  if (step < 2) return base;
+  const soft = base * 1.2 ** (step - 1);
+  return Math.min(cap, soft);
+}
+async function waitFor(args) {
+  const timeout = args.timeout ?? 6e5;
+  const initial = args.initialInterval ?? DEFAULT_BASE;
+  const cap = args.intervalCap ?? DEFAULT_CAP;
+  const deadline = Date.now() + timeout;
+  let step = 0;
+  while (true) {
+    const doc = await args.fetch();
+    if (args.onUpdate) {
+      try {
+        args.onUpdate(doc);
+      } catch {
+      }
+    }
+    if (args.isTerminal(doc)) return doc;
+    const now = Date.now();
+    if (now >= deadline) {
+      throw new NopaqueTimeoutError(`waitFor timed out after ${timeout}ms`);
+    }
+    const interval = Math.min(
+      pollIntervalCurve(step, { base: initial, cap }),
+      Math.max(0, deadline - now)
+    );
+    await new Promise((r) => setTimeout(r, interval));
+    step++;
+  }
+}
+
+// src/resources/batches.ts
+var RUN_TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+var BatchesResource = class extends Resource {
+  async create(body, requestOptions) {
+    return await this.transport.request("POST", "/testing/batches", { body, requestOptions });
+  }
+  list(params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => await this.transport.request("GET", "/testing/batches", { params: p, requestOptions }),
+      params: { ...params },
+      itemsKey: "batches"
+    });
+  }
+  async listPage(params = {}, requestOptions) {
+    const raw = await this.transport.request("GET", "/testing/batches", { params, requestOptions });
+    return new Page(raw.batches ?? raw.items ?? [], raw.nextToken ?? null);
+  }
+  async get(batchId, requestOptions) {
+    return await this.transport.request("GET", `/testing/batches/${batchId}`, { requestOptions });
+  }
+  async update(batchId, body, requestOptions) {
+    return await this.transport.request("PUT", `/testing/batches/${batchId}`, {
+      body,
+      requestOptions
+    });
+  }
+  async delete(batchId, requestOptions) {
+    await this.transport.request("DELETE", `/testing/batches/${batchId}`, { requestOptions });
+  }
+  async run(batchId, requestOptions) {
+    return await this.transport.request("POST", `/testing/batches/${batchId}/run`, {
+      requestOptions
+    });
+  }
+  runs(batchId, params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => await this.transport.request("GET", `/testing/batches/${batchId}/runs`, {
+        params: p,
+        requestOptions
+      }),
+      params: { ...params },
+      itemsKey: "runs"
+    });
+  }
+  listRuns(params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => await this.transport.request("GET", "/testing/batch-runs", {
+        params: p,
+        requestOptions
+      }),
+      params: { ...params },
+      itemsKey: "runs"
+    });
+  }
+  async getRun(runId, requestOptions) {
+    return await this.transport.request("GET", `/testing/batch-runs/${runId}`, { requestOptions });
+  }
+  async waitForRun(runId, opts = {}) {
+    return await waitFor({
+      fetch: () => this.getRun(runId, opts.requestOptions),
+      isTerminal: (run) => RUN_TERMINAL_STATUSES.has(run.status),
+      timeout: opts.timeout,
+      initialInterval: opts.pollInterval,
+      intervalCap: opts.intervalCap,
+      onUpdate: opts.onUpdate
+    });
+  }
+};
+
+// src/resources/datasets.ts
+var DatasetsResource = class extends Resource {
+  async create(body, requestOptions) {
+    return await this.transport.request("POST", "/datasets", { body, requestOptions });
+  }
+  list(params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => await this.transport.request("GET", "/datasets", { params: p, requestOptions }),
+      params: { ...params },
+      itemsKey: "datasets"
+    });
+  }
+  async listPage(params = {}, requestOptions) {
+    const raw = await this.transport.request("GET", "/datasets", { params, requestOptions });
+    return new Page(raw.datasets ?? raw.items ?? [], raw.nextToken ?? null);
+  }
+  async get(datasetId, requestOptions) {
+    return await this.transport.request("GET", `/datasets/${datasetId}`, { requestOptions });
+  }
+  async update(datasetId, body, requestOptions) {
+    return await this.transport.request("PUT", `/datasets/${datasetId}`, { body, requestOptions });
+  }
+  async delete(datasetId, requestOptions) {
+    await this.transport.request("DELETE", `/datasets/${datasetId}`, { requestOptions });
+  }
+  async resolve(datasetId, requestOptions) {
+    return await this.transport.request("GET", `/datasets/${datasetId}/resolve`, {
+      requestOptions
+    });
+  }
+};
+
+// src/resources/enrichment.ts
+var EnrichmentResource = class extends Resource {
+  async get(jobId, runId, type, requestOptions) {
+    return await this.transport.request(
+      "GET",
+      `/mapping/${jobId}/runs/${runId}/enrichments/${encodeURIComponent(type)}`,
+      { requestOptions }
+    );
+  }
+  async tokenUsage(jobId, runId, requestOptions) {
+    return await this.transport.request(
+      "GET",
+      `/mapping/${jobId}/runs/${runId}/token-usage`,
+      { requestOptions }
+    );
+  }
+  async enrich(jobId, runId, body, requestOptions) {
+    return await this.transport.request(
+      "POST",
+      `/mapping/${jobId}/runs/${runId}/enrich`,
+      { body, requestOptions }
+    );
+  }
+};
+
+// src/resources/loadTesting.ts
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "aborted", "failed"]);
+var LoadTestingResource = class extends Resource {
+  async create(body, requestOptions) {
+    const raw = await this.transport.request(
+      "POST",
+      "/testing/load-tests",
+      { body, requestOptions }
+    );
+    return raw.config ?? raw;
+  }
+  list(params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => await this.transport.request("GET", "/testing/load-tests", {
+        params: p,
+        requestOptions
+      }),
+      params: { ...params },
+      itemsKey: "configs"
+    });
+  }
+  async listPage(params = {}, requestOptions) {
+    const raw = await this.transport.request("GET", "/testing/load-tests", { params, requestOptions });
+    return new Page(raw.configs ?? raw.items ?? [], raw.nextToken ?? null);
+  }
+  async get(loadTestId, requestOptions) {
+    return await this.transport.request("GET", `/testing/load-tests/${loadTestId}`, {
+      requestOptions
+    });
+  }
+  async update(loadTestId, body, requestOptions) {
+    const raw = await this.transport.request(
+      "PUT",
+      `/testing/load-tests/${loadTestId}`,
+      { body, requestOptions }
+    );
+    return raw.config ?? raw;
+  }
+  async delete(loadTestId, requestOptions) {
+    await this.transport.request("DELETE", `/testing/load-tests/${loadTestId}`, { requestOptions });
+  }
+  async estimate(body, requestOptions) {
+    return await this.transport.request("POST", "/testing/load-tests/estimate", {
+      body,
+      requestOptions
+    });
+  }
+  async start(loadTestId, requestOptions) {
+    return await this.transport.request("POST", `/testing/load-tests/${loadTestId}/start`, {
+      requestOptions
+    });
+  }
+  async abort(loadTestId, requestOptions) {
+    return await this.transport.request("POST", `/testing/load-tests/${loadTestId}/abort`, {
+      requestOptions
+    });
+  }
+  async status(loadTestId, requestOptions) {
+    return await this.transport.request("GET", `/testing/load-tests/${loadTestId}/status`, {
+      requestOptions
+    });
+  }
+  listRuns(params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => await this.transport.request("GET", "/testing/load-tests/runs", {
+        params: p,
+        requestOptions
+      }),
+      params: { ...params },
+      itemsKey: "runs"
+    });
+  }
+  async waitForComplete(loadTestId, opts = {}) {
+    return await waitFor({
+      fetch: () => this.status(loadTestId, opts.requestOptions),
+      isTerminal: (s) => TERMINAL_STATUSES.has(s.status),
+      timeout: opts.timeout,
+      initialInterval: opts.pollInterval,
+      intervalCap: opts.intervalCap,
+      onUpdate: opts.onUpdate
+    });
+  }
+};
+
+// src/resources/mapping.ts
+var TERMINAL_STATUSES2 = /* @__PURE__ */ new Set(["completed", "failed", "limited", "cancelled"]);
+var MappingResource = class extends Resource {
+  list(params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => await this.transport.request("GET", "/mapping", { params: p, requestOptions }),
+      params: { ...params }
+    });
+  }
+  async listPage(params = {}, requestOptions) {
+    const raw = await this.transport.request(
+      "GET",
+      "/mapping",
+      { params, requestOptions }
+    );
+    return new Page(raw.items, raw.nextToken);
+  }
+  async get(jobId, requestOptions) {
+    return await this.transport.request("GET", `/mapping/${jobId}`, { requestOptions });
+  }
+  async create(body, requestOptions) {
+    return await this.transport.request("POST", "/mapping", { body, requestOptions });
+  }
+  async update(jobId, body, requestOptions) {
+    return await this.transport.request("PATCH", `/mapping/${jobId}`, { body, requestOptions });
+  }
+  async delete(jobId, requestOptions) {
+    await this.transport.request("DELETE", `/mapping/${jobId}`, { requestOptions });
+  }
+  async start(jobId, requestOptions) {
+    return await this.transport.request("POST", `/mapping/${jobId}/start`, { requestOptions });
+  }
+  async cancel(jobId, requestOptions) {
+    return await this.transport.request("POST", `/mapping/${jobId}/cancel`, { requestOptions });
+  }
+  async attest(jobId, requestOptions) {
+    return await this.transport.request("POST", "/mapping/attest", {
+      body: { jobId },
+      requestOptions
+    });
+  }
+  steps(jobId, params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => await this.transport.request("GET", `/mapping/${jobId}/steps`, {
+        params: p,
+        requestOptions
+      }),
+      params: { ...params }
+    });
+  }
+  async tree(jobId, opts = {}, requestOptions) {
+    return await this.transport.request("GET", `/mapping/${jobId}/tree`, {
+      params: { format: opts.format ?? "tree" },
+      requestOptions
+    });
+  }
+  runs(jobId, params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => await this.transport.request("GET", `/mapping/${jobId}/runs`, {
+        params: p,
+        requestOptions
+      }),
+      params: { ...params },
+      itemsKey: "runs"
+    });
+  }
+  paths(jobId, params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => await this.transport.request("GET", `/mapping/${jobId}/paths`, {
+        params: p,
+        requestOptions
+      }),
+      params: { ...params },
+      itemsKey: "rules"
+    });
+  }
+  async updatePath(jobId, path, body, requestOptions) {
+    return await this.transport.request(
+      "PATCH",
+      `/mapping/${jobId}/paths/${encodeURIComponent(path)}`,
+      { body, requestOptions }
+    );
+  }
+  async deletePath(jobId, path, requestOptions) {
+    await this.transport.request(
+      "DELETE",
+      `/mapping/${jobId}/paths/${encodeURIComponent(path)}`,
+      { requestOptions }
+    );
+  }
+  async remap(jobId, path, requestOptions) {
+    return await this.transport.request(
+      "POST",
+      `/mapping/${jobId}/remap/${encodeURIComponent(path)}`,
+      { requestOptions }
+    );
+  }
+  async probe(jobId, runId, body = {}, requestOptions) {
+    return await this.transport.request(
+      "POST",
+      `/mapping/${jobId}/runs/${runId}/probe`,
+      { body, requestOptions }
+    );
+  }
+  async waitForComplete(jobId, opts = {}) {
+    return await waitFor({
+      fetch: () => this.get(jobId, opts.requestOptions),
+      isTerminal: (job) => TERMINAL_STATUSES2.has(job.status),
+      timeout: opts.timeout,
+      initialInterval: opts.pollInterval,
+      intervalCap: opts.intervalCap,
+      onUpdate: opts.onUpdate
+    });
+  }
+};
+
+// src/resources/profiles.ts
+var ProfilesResource = class extends Resource {
+  async create(body, requestOptions) {
+    return await this.transport.request("POST", "/profiles", { body, requestOptions });
+  }
+  list(params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => await this.transport.request("GET", "/profiles", { params: p, requestOptions }),
+      params: { ...params },
+      itemsKey: "profiles"
+    });
+  }
+  async listPage(params = {}, requestOptions) {
+    const raw = await this.transport.request("GET", "/profiles", { params, requestOptions });
+    return new Page(raw.profiles ?? raw.items ?? [], raw.nextToken ?? null);
+  }
+  async get(profileId, requestOptions) {
+    return await this.transport.request("GET", `/profiles/${profileId}`, { requestOptions });
+  }
+  async update(profileId, body, requestOptions) {
+    return await this.transport.request("PUT", `/profiles/${profileId}`, { body, requestOptions });
+  }
+  async delete(profileId, requestOptions) {
+    await this.transport.request("DELETE", `/profiles/${profileId}`, { requestOptions });
+  }
+  async addItem(profileId, body, requestOptions) {
+    return await this.transport.request("POST", `/profiles/${profileId}/items`, {
+      body,
+      requestOptions
+    });
+  }
+  async updateItem(profileId, itemId, body, requestOptions) {
+    return await this.transport.request("PUT", `/profiles/${profileId}/items/${itemId}`, {
+      body,
+      requestOptions
+    });
+  }
+  async deleteItem(profileId, itemId, requestOptions) {
+    await this.transport.request(
+      "DELETE",
+      `/profiles/${profileId}/items/${itemId}`,
+      { requestOptions }
+    );
+  }
+  async listParameters(requestOptions) {
+    return await this.transport.request("GET", "/profiles/parameters", { requestOptions });
+  }
+  async findByParameters(params, requestOptions) {
+    const labels = Array.isArray(params.labels) ? params.labels.join(",") : params.labels;
+    return await this.transport.request("GET", "/profiles/by-parameters", {
+      params: { labels },
+      requestOptions
+    });
+  }
+};
+
+// src/resources/scheduler.ts
+var SchedulerResource = class extends Resource {
+  async create(body, requestOptions) {
+    return await this.transport.request("POST", "/schedules", { body, requestOptions });
+  }
+  list(params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => await this.transport.request("GET", "/schedules", { params: p, requestOptions }),
+      params: { ...params },
+      itemsKey: "schedules"
+    });
+  }
+  async listPage(params = {}, requestOptions) {
+    const raw = await this.transport.request("GET", "/schedules", { params, requestOptions });
+    return new Page(raw.schedules ?? raw.items ?? [], raw.nextToken ?? null);
+  }
+  async get(scheduleId, requestOptions) {
+    return await this.transport.request("GET", `/schedules/${scheduleId}`, { requestOptions });
+  }
+  async update(scheduleId, body, requestOptions) {
+    return await this.transport.request("PUT", `/schedules/${scheduleId}`, { body, requestOptions });
+  }
+  async delete(scheduleId, requestOptions) {
+    await this.transport.request("DELETE", `/schedules/${scheduleId}`, { requestOptions });
+  }
+  async pause(scheduleId, requestOptions) {
+    return await this.transport.request("POST", `/schedules/${scheduleId}/pause`, {
+      requestOptions
+    });
+  }
+  async resume(scheduleId, requestOptions) {
+    return await this.transport.request("POST", `/schedules/${scheduleId}/resume`, {
+      requestOptions
+    });
+  }
+};
+
+// src/resources/sweeps.ts
+var RUN_TERMINAL_STATUSES2 = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+var SweepsResource = class extends Resource {
+  async create(body, requestOptions) {
+    return await this.transport.request("POST", "/testing/sweeps", { body, requestOptions });
+  }
+  list(params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => await this.transport.request("GET", "/testing/sweeps", { params: p, requestOptions }),
+      params: { ...params },
+      itemsKey: "sweeps"
+    });
+  }
+  async listPage(params = {}, requestOptions) {
+    const raw = await this.transport.request("GET", "/testing/sweeps", { params, requestOptions });
+    return new Page(raw.sweeps ?? raw.items ?? [], raw.nextToken ?? null);
+  }
+  async get(sweepId, requestOptions) {
+    return await this.transport.request("GET", `/testing/sweeps/${sweepId}`, { requestOptions });
+  }
+  async update(sweepId, body, requestOptions) {
+    return await this.transport.request("PUT", `/testing/sweeps/${sweepId}`, {
+      body,
+      requestOptions
+    });
+  }
+  async delete(sweepId, requestOptions) {
+    await this.transport.request("DELETE", `/testing/sweeps/${sweepId}`, { requestOptions });
+  }
+  async run(sweepId, requestOptions) {
+    return await this.transport.request("POST", `/testing/sweeps/${sweepId}/run`, {
+      requestOptions
+    });
+  }
+  runs(sweepId, params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => await this.transport.request("GET", `/testing/sweeps/${sweepId}/runs`, {
+        params: p,
+        requestOptions
+      }),
+      params: { ...params },
+      itemsKey: "runs"
+    });
+  }
+  listRuns(params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => await this.transport.request("GET", "/testing/sweep-runs", {
+        params: p,
+        requestOptions
+      }),
+      params: { ...params },
+      itemsKey: "runs"
+    });
+  }
+  async getRun(runId, requestOptions) {
+    return await this.transport.request("GET", `/testing/sweep-runs/${runId}`, { requestOptions });
+  }
+  async waitForRun(runId, opts = {}) {
+    return await waitFor({
+      fetch: () => this.getRun(runId, opts.requestOptions),
+      isTerminal: (run) => RUN_TERMINAL_STATUSES2.has(run.status),
+      timeout: opts.timeout,
+      initialInterval: opts.pollInterval,
+      intervalCap: opts.intervalCap,
+      onUpdate: opts.onUpdate
+    });
+  }
+};
+
+// src/resources/testing.ts
+var RUN_TERMINAL_STATUSES3 = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+var TestingConfigsResource = class extends Resource {
+  async create(body, requestOptions) {
+    return await this.transport.request("POST", "/testing/configs", { body, requestOptions });
+  }
+  list(params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => {
+        const raw = await this.transport.request("GET", "/testing/configs", { params: p, requestOptions });
+        return { items: raw.configs ?? raw.items ?? [], nextToken: null };
+      },
+      params: { ...params }
+    });
+  }
+  async listPage(params = {}, requestOptions) {
+    const raw = await this.transport.request("GET", "/testing/configs", { params, requestOptions });
+    return new Page(raw.configs ?? raw.items ?? [], raw.nextToken ?? null);
+  }
+  async get(configId, requestOptions) {
+    return await this.transport.request("GET", `/testing/configs/${configId}`, { requestOptions });
+  }
+  async update(configId, body, requestOptions) {
+    return await this.transport.request("PUT", `/testing/configs/${configId}`, {
+      body,
+      requestOptions
+    });
+  }
+  async delete(configId, requestOptions) {
+    await this.transport.request("DELETE", `/testing/configs/${configId}`, { requestOptions });
+  }
+};
+var TestingJobsResource = class extends Resource {
+  async create(body, requestOptions) {
+    return await this.transport.request("POST", "/testing/jobs", { body, requestOptions });
+  }
+  list(params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => {
+        const raw = await this.transport.request("GET", "/testing/jobs", { params: p, requestOptions });
+        return { items: raw.jobs ?? raw.items ?? [], nextToken: null };
+      },
+      params: { ...params }
+    });
+  }
+  async listPage(params = {}, requestOptions) {
+    const raw = await this.transport.request("GET", "/testing/jobs", { params, requestOptions });
+    return new Page(raw.jobs ?? raw.items ?? [], raw.nextToken ?? null);
+  }
+  async get(jobId, requestOptions) {
+    return await this.transport.request("GET", `/testing/jobs/${jobId}`, { requestOptions });
+  }
+  async delete(jobId, requestOptions) {
+    await this.transport.request("DELETE", `/testing/jobs/${jobId}`, { requestOptions });
+  }
+};
+var TestingRunsResource = class extends Resource {
+  async create(body, requestOptions) {
+    const raw = await this.transport.request(
+      "POST",
+      "/testing/runs",
+      { body, requestOptions }
+    );
+    return raw.run ?? raw;
+  }
+  list(params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => {
+        const raw = await this.transport.request("GET", "/testing/runs", { params: p, requestOptions });
+        return { items: raw.runs ?? raw.items ?? [], nextToken: null };
+      },
+      params: { ...params }
+    });
+  }
+  async listPage(params = {}, requestOptions) {
+    const raw = await this.transport.request("GET", "/testing/runs", { params, requestOptions });
+    return new Page(raw.runs ?? raw.items ?? [], raw.nextToken ?? null);
+  }
+  async get(runId, requestOptions) {
+    return await this.transport.request("GET", `/testing/runs/${runId}`, { requestOptions });
+  }
+  async waitForRun(runId, opts = {}) {
+    return await waitFor({
+      fetch: () => this.get(runId, opts.requestOptions),
+      isTerminal: (run) => run.status !== void 0 && RUN_TERMINAL_STATUSES3.has(run.status),
+      timeout: opts.timeout,
+      initialInterval: opts.pollInterval,
+      intervalCap: opts.intervalCap,
+      onUpdate: opts.onUpdate
+    });
+  }
+};
+var TestingResource = class extends Resource {
+  configs;
+  jobs;
+  runs;
+  constructor(transport) {
+    super(transport);
+    this.configs = new TestingConfigsResource(transport);
+    this.jobs = new TestingJobsResource(transport);
+    this.runs = new TestingRunsResource(transport);
+  }
+};
+
+// src/client.ts
+var Nopaque = class {
+  mapping;
+  audio;
+  profiles;
+  testing;
+  batches;
+  sweeps;
+  datasets;
+  loadTesting;
+  scheduler;
+  enrichment;
+  transport;
+  constructor(options = {}) {
+    const config = resolveConfig(options);
+    this.transport = new Transport(config);
+    this.mapping = new MappingResource(this.transport);
+    this.audio = new AudioResource(this.transport);
+    this.profiles = new ProfilesResource(this.transport);
+    this.testing = new TestingResource(this.transport);
+    this.batches = new BatchesResource(this.transport);
+    this.sweeps = new SweepsResource(this.transport);
+    this.datasets = new DatasetsResource(this.transport);
+    this.loadTesting = new LoadTestingResource(this.transport);
+    this.scheduler = new SchedulerResource(this.transport);
+    this.enrichment = new EnrichmentResource(this.transport);
+  }
+  close() {
+  }
+};
+export {
+  APIConnectionError,
+  APITimeoutError,
+  AuthenticationError,
+  ConflictError,
+  Nopaque,
+  NopaqueAPIError,
+  NopaqueConfigError,
+  NopaqueError,
+  NopaqueTimeoutError,
+  NotFoundError,
+  Page,
+  Paginator,
+  PermissionError,
+  RateLimitError,
+  ServerError,
+  VERSION,
+  ValidationError
+};
+//# sourceMappingURL=index.mjs.map