@nopaque/sdk 0.1.1 → 0.4.0

package/CHANGELOG.md

@@ -4,6 +4,96 @@ All notable changes to this project will be documented in this file.
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.0] - 2026-08-12
+
+### Added
+
+- Digital (chat channel) testing, in beta. Access is limited to beta workspaces
+  during the beta period.
+  - `client.digitalTesting` — create, list, get, cancel and wait for digital test runs.
+  - `client.digitalTestConfigs` — save, update, delete and launch reusable digital test configs.
+  - `client.digitalCompliance` — list digital compliance audits and fetch a per-target report.
+  - `DigitalSample` carries the shapes the API actually returns, which differ
+    from the OpenAPI document: `transcript` is a `DigitalTranscriptTurn[]`
+    (`role`/`text`/`at`), not a string, and evidence arrives as separate
+    `passEvidence` / `failEvidence` arrays of `DigitalEvidence`
+    (`condition`/`reason`) — there is no combined `evidence` field.
+  - `DigitalTestRun.configId` — set when the run was launched from a saved
+    config. Returned by the API but undeclared in the OpenAPI document.
+- `client.testing.listVoices()` — the operator-enabled voices a mission test may
+  use, and which is the default.
+
+## [0.3.0] - 2026-07-09
+
+### Added
+
+All changes are additive and backward-compatible with existing signatures.
+
+- **Mapping**
+  - `tags?: string[]` on `CreateMappingJobRequest`, `UpdateMappingJobRequest`,
+    and the `MappingJob` response type.
+  - `mapping.list()` now accepts the full server filter + pagination surface:
+    `phoneNumber`, `name`, `profileId`, `tag`, `status`, `createdAfter`,
+    `createdBefore`, `sort`, `sortDir`, `limit`, `cursor`. It returns slim
+    `MappingJobListItem` values and reads `nextCursor` (falling back to the
+    `nextToken` back-compat alias) for pagination.
+  - Single-job response (`mapping.get()`) gains `runNumber?` and a nested
+    `currentRun?` summary (omitted, never null, when the job has no run).
+  - Tree nodes gain the enrichment fields (`stepType`, `voicePrompt`,
+    `menuLabel`, `spokenResponse`, `probeCategory`, `probeClassification`,
+    `probeRationale`, `audioUrl`, `duration`, `inputRequired`), tree/flat-tree
+    responses gain `runNumber?`, and the empty-state envelope
+    (`tree: null` + `reason`/`message`) is now typed — branch on `tree === null`.
+  - New permissive `CallTelemetry` / `TurnTelemetry` types (all fields optional,
+    unknown keys tolerated); `callTelemetry?` may appear on `MappingRun` and
+    `turnTelemetry?` on step results.
+- **Testing**
+  - `testing.runs.list()` (and the `testing.listRuns()` alias) gain filter +
+    pagination params (`jobId`, `runType`, `outcome`, `phoneNumber`, `configId`,
+    `catalogueTestId`, `startedAfter`, `startedBefore`, `sortBy`, `sortDir`,
+    `limit`, `cursor`), returning slim `TestRunListItem` values with `nextCursor`.
+  - `testing.aggregateRuns(params)` for `GET /testing/runs/aggregate`.
+  - `testing.getMissionTestRun(id)` for `GET /testing/mission-test-runs/{id}`.
+- **Mission test configs**
+  - `tags?: string[]` on `MissionTestConfig` and `CreateMissionTestConfigRequest`,
+    plus `description?` and `phoneNumber?`.
+  - `missionTestConfigs.update(id, body)` (PATCH partial update; `description`
+    and `tags` accept `null` to clear).
+  - `missionTestConfigs.list()` gains filter + pagination params
+    (`name`, `phoneNumber`, `sector`, `profileId`, `tag`, `createdAfter`,
+    `createdBefore`, `sort`, `sortDir`, `limit`, `cursor`) and returns slim
+    `MissionTestConfigListItem` values.
+
+## [0.1.2] - 2026-05-03
+
+### Fixed
+- `mappingMode` placement in `CreateMappingJobRequest` and
+  `UpdateMappingJobRequest`. The field is moved into `MappingJobConfig`
+  to match what the live API actually accepts (the API reads
+  `body.config.mappingMode`, not `body.mappingMode`). Calls in 0.1.1
+  with `mappingMode` at the top level were silently being rejected by
+  the API as "mappingMode is required".
+- `MappingJob` response type also drops top-level `mappingMode` for
+  consistency. Read the value from `job.config?.mappingMode` instead.
+
+### Migration
+
+```ts
+// Before (0.1.1) — sent the value at the top level; API rejected it.
+client.mapping.create({
+  name: 'Main',
+  phoneNumber: '+44...',
+  mappingMode: 'dtmf',
+});
+
+// After (0.1.2) — nested under config; API accepts.
+client.mapping.create({
+  name: 'Main',
+  phoneNumber: '+44...',
+  config: { mappingMode: 'dtmf' },
+});
+```
+
 ## [0.1.1] - 2026-04-21
 
 ### Fixed

package/README.md

@@ -23,7 +23,7 @@ const client = new Nopaque({ apiKey: process.env.NOPAQUE_API_KEY });
 const job = await client.mapping.create({
   name: 'Main IVR',
   phoneNumber: '+441234567890',
-  mappingMode: 'dtmf',
+  config: { mappingMode: 'dtmf' },
 });
 await client.mapping.start(job.id);
 const final = await client.mapping.waitForComplete(job.id);
@@ -35,6 +35,26 @@ for await (const audio of client.audio.list()) {
 }
 ```
 
+### Digital testing (beta)
+
+Access is limited to beta workspaces during the beta period.
+
+```ts
+const run = await client.digitalTesting.create({
+  targetRef: 'acme/billing-bot',
+  target: { transport: 'web-widget', url: 'https://example.com/support' },
+  // `sector` and `mission` are required on every digital run.
+  sector: 'utilities',
+  mission: 'Pay my bill',
+  kind: 'freeform',
+  acceptance: 'The bot states the outstanding balance.',
+});
+
+const finished = await client.digitalTesting.waitForRun(run.id);
+// `completed` with outcome 'fail' is a RESULT, not an error.
+console.log(finished.status, finished.outcome, finished.passRate);
+```
+
 ## Features
 
 - Full coverage of the Nopaque REST API via API-key auth

package/dist/index.cjs

@@ -133,7 +133,7 @@ function resolveConfig(opts) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.1.1" : "0.0.0-dev";
+var VERSION = true ? "0.4.0" : "0.0.0-dev";
 
 // src/userAgent.ts
 function composeUserAgent() {
@@ -491,7 +491,13 @@ var AudioResource = class extends Resource {
     const resolvedName = input.name ?? inferredName ?? "upload.bin";
     const resolvedType = input.contentType ?? sniffContentType(resolvedName);
     const presign = await this.createUploadUrl(
-      { fileName: resolvedName, contentType: resolvedType },
+      {
+        filename: resolvedName,
+        contentType: resolvedType,
+        category: input.category,
+        ...input.associatedId && { associatedId: input.associatedId },
+        sizeBytes: bytes.byteLength
+      },
       requestOptions
     );
     await s3Put(presign.uploadUrl, bytes, {
@@ -616,6 +622,62 @@ var BatchesResource = class extends Resource {
   }
 };
 
+// src/resources/compliance.ts
+function encodePhone(phoneNumber) {
+  return encodeURIComponent(phoneNumber);
+}
+var ComplianceResource = class extends Resource {
+  async getCatalogue(params = {}, requestOptions) {
+    return await this.transport.request("GET", "/testing/compliance-catalogue", { params, requestOptions });
+  }
+  // Atomic batch dispatch. Server enforces compliancePickerLimits[tier] on
+  // testIds.length and returns 402 with code='BATCH_SIZE_EXCEEDS_TIER' on
+  // overflow. Surfaces as a typed NopaqueAPIError with code preserved.
+  async run(body, requestOptions) {
+    return await this.transport.request("POST", "/testing/compliance-runs", { body, requestOptions });
+  }
+  listReports(params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => await this.transport.request("GET", "/testing/compliance-reports", { params: p, requestOptions }),
+      params: { ...params }
+    });
+  }
+  async listReportsPage(params = {}, requestOptions) {
+    const raw = await this.transport.request("GET", "/testing/compliance-reports", { params, requestOptions });
+    return new Page(raw.items, raw.nextToken);
+  }
+  async getReport(phoneNumber, requestOptions) {
+    return await this.transport.request(
+      "GET",
+      `/testing/compliance-reports/${encodePhone(phoneNumber)}`,
+      { requestOptions }
+    );
+  }
+  // Returns the presigned S3 URL the platform uploaded the PDF to. The 1 hour
+  // expiry is baked into the URL itself; the response body is `{ url }` only.
+  async generatePdfUrl(phoneNumber, body = {}, requestOptions) {
+    return await this.transport.request(
+      "POST",
+      `/testing/compliance-reports/${encodePhone(phoneNumber)}/pdf`,
+      { body, requestOptions }
+    );
+  }
+  // Convenience: get the URL, then fetch the bytes. For applications that
+  // already have an HTTP client, prefer generatePdfUrl() and fetch the URL
+  // with that client instead.
+  async downloadReportPdf(phoneNumber, body = {}, requestOptions) {
+    const { url } = await this.generatePdfUrl(phoneNumber, body, requestOptions);
+    const response = await this.transport.config.fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to download PDF: ${response.status} ${response.statusText}`);
+    }
+    return new Uint8Array(await response.arrayBuffer());
+  }
+  async rerun(runId, requestOptions) {
+    return await this.transport.request("POST", `/testing/compliance-runs/${runId}/rerun`, { requestOptions });
+  }
+};
+
 // src/resources/datasets.ts
 var DatasetsResource = class extends Resource {
   async create(body, requestOptions) {
@@ -648,6 +710,207 @@ var DatasetsResource = class extends Resource {
   }
 };
 
+// src/resources/digitalCompliance.ts
+var DigitalComplianceResource = class extends Resource {
+  /**
+   * List digital compliance audits, one entry per target.
+   *
+   * @beta Access is limited to beta workspaces during the beta period.
+   */
+  async listAudits(requestOptions) {
+    const raw = await this.transport.request(
+      "GET",
+      "/digital-testing/compliance-audits",
+      { requestOptions }
+    );
+    return raw.audits ?? [];
+  }
+  /**
+   * Compliance report for one digital target.
+   *
+   * `targetRef` goes in the QUERY STRING, not the path: a targetRef contains
+   * slashes (`acme/billing-bot`) and a single path segment cannot hold one. The
+   * API made the same choice for the same reason.
+   *
+   * Pass `{ sector }` to restrict the catalogue to tests applicable to that sector.
+   *
+   * @beta Access is limited to beta workspaces during the beta period.
+   */
+  async getReport(targetRef, params = {}, requestOptions) {
+    return await this.transport.request("GET", "/digital-testing/compliance-audits/report", {
+      params: { targetRef, ...params },
+      requestOptions
+    });
+  }
+};
+
+// src/resources/digitalTestConfigs.ts
+var DigitalTestConfigsResource = class extends Resource {
+  /** @beta Access is limited to beta workspaces during the beta period. */
+  list(params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => {
+        const { nextToken, cursor, ...rest } = p;
+        const raw = await this.transport.request(
+          "GET",
+          "/digital-testing/configs",
+          {
+            // `nextToken` first: the Paginator advances by writing it, and a
+            // caller-supplied `cursor` would otherwise pin every page to page one.
+            params: { ...rest, cursor: nextToken ?? cursor },
+            requestOptions
+          }
+        );
+        return {
+          items: raw.configs ?? raw.items ?? [],
+          nextToken: raw.nextCursor ?? raw.nextToken ?? null
+        };
+      },
+      params: { ...params }
+    });
+  }
+  /** @beta Access is limited to beta workspaces during the beta period. */
+  async listPage(params = {}, requestOptions) {
+    const { nextToken, cursor, ...rest } = params;
+    const raw = await this.transport.request("GET", "/digital-testing/configs", {
+      params: { ...rest, cursor: nextToken ?? cursor },
+      requestOptions
+    });
+    return new Page(raw.configs ?? raw.items ?? [], raw.nextCursor ?? raw.nextToken ?? null);
+  }
+  /**
+   * Save a digital test config. Per-kind rules are enforced at SAVE time, so a
+   * config that could never run is rejected with 400 rather than stored.
+   *
+   * @beta Access is limited to beta workspaces during the beta period.
+   */
+  async create(body, requestOptions) {
+    return await this.transport.request("POST", "/digital-testing/configs", {
+      body,
+      requestOptions
+    });
+  }
+  /** @beta Access is limited to beta workspaces during the beta period. */
+  async get(configId, requestOptions) {
+    return await this.transport.request("GET", `/digital-testing/configs/${configId}`, {
+      requestOptions
+    });
+  }
+  /** @beta Access is limited to beta workspaces during the beta period. */
+  async update(configId, body, requestOptions) {
+    return await this.transport.request("PATCH", `/digital-testing/configs/${configId}`, {
+      body,
+      requestOptions
+    });
+  }
+  /** @beta Access is limited to beta workspaces during the beta period. */
+  async delete(configId, requestOptions) {
+    await this.transport.request("DELETE", `/digital-testing/configs/${configId}`, {
+      requestOptions
+    });
+  }
+  /**
+   * Launch a run from a saved config. `target` and `targetRef` must be
+   * overridden together — a half-override is a 400.
+   *
+   * @beta Access is limited to beta workspaces during the beta period.
+   */
+  async launch(configId, body = {}, requestOptions) {
+    const raw = await this.transport.request("POST", `/digital-testing/configs/${configId}/runs`, { body, requestOptions });
+    return raw.run ?? raw;
+  }
+};
+
+// src/resources/digitalTesting.ts
+var TERMINAL = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+var DigitalTestingResource = class extends Resource {
+  /**
+   * Queue a digital test run.
+   *
+   * @beta Access is limited to beta workspaces during the beta period.
+   */
+  async create(body, requestOptions) {
+    const raw = await this.transport.request("POST", "/digital-testing/runs", { body, requestOptions });
+    return raw.run ?? raw;
+  }
+  /**
+   * Paginated list of digital test runs, newest first.
+   *
+   * @beta Access is limited to beta workspaces during the beta period.
+   */
+  list(params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => {
+        const { nextToken, cursor, ...rest } = p;
+        const raw = await this.transport.request("GET", "/digital-testing/runs", {
+          // `nextToken` first: the Paginator advances by writing it, and a
+          // caller-supplied `cursor` would otherwise pin every page to page one.
+          params: { ...rest, cursor: nextToken ?? cursor },
+          requestOptions
+        });
+        return {
+          items: raw.runs ?? raw.items ?? [],
+          nextToken: raw.nextCursor ?? raw.nextToken ?? null
+        };
+      },
+      params: { ...params }
+    });
+  }
+  /**
+   * One page of digital test runs.
+   *
+   * @beta Access is limited to beta workspaces during the beta period.
+   */
+  async listPage(params = {}, requestOptions) {
+    const { nextToken, cursor, ...rest } = params;
+    const raw = await this.transport.request("GET", "/digital-testing/runs", {
+      params: { ...rest, cursor: nextToken ?? cursor },
+      requestOptions
+    });
+    return new Page(raw.runs ?? raw.items ?? [], raw.nextCursor ?? raw.nextToken ?? null);
+  }
+  /**
+   * Get one digital test run.
+   *
+   * @beta Access is limited to beta workspaces during the beta period.
+   */
+  async get(runId, requestOptions) {
+    return await this.transport.request("GET", `/digital-testing/runs/${runId}`, {
+      requestOptions
+    });
+  }
+  /**
+   * Cancel a digital test run.
+   *
+   * @beta Access is limited to beta workspaces during the beta period.
+   */
+  async cancel(runId, requestOptions) {
+    return await this.transport.request("POST", `/digital-testing/runs/${runId}/cancel`, {
+      requestOptions
+    });
+  }
+  /**
+   * Poll until the run reaches a terminal state.
+   *
+   * Resolves on `completed`, `failed` and `cancelled` alike and returns the run.
+   * A bot that behaved badly is `completed` with `outcome: 'fail'`, which is a
+   * RESULT, not an error — this never throws on it. `failed` means the test could
+   * not be delivered.
+   *
+   * @beta Access is limited to beta workspaces during the beta period.
+   */
+  async waitForRun(runId, opts = {}) {
+    return await waitFor({
+      fetch: () => this.get(runId, opts.requestOptions),
+      isTerminal: (r) => TERMINAL.has(r.status),
+      timeout: opts.timeout,
+      initialInterval: opts.pollInterval,
+      intervalCap: opts.intervalCap,
+      onUpdate: opts.onUpdate
+    });
+  }
+};
+
 // src/resources/enrichment.ts
 var EnrichmentResource = class extends Resource {
   async get(jobId, runId, type, requestOptions) {
@@ -762,17 +1025,24 @@ var TERMINAL_STATUSES2 = /* @__PURE__ */ new Set(["completed", "failed", "limite
 var MappingResource = class extends Resource {
   list(params = {}, requestOptions) {
     return new Paginator({
-      fetchPage: async (p) => await this.transport.request("GET", "/mapping", { params: p, requestOptions }),
+      fetchPage: async (p) => {
+        const { nextToken, cursor, ...rest } = p;
+        const raw = await this.transport.request("GET", "/mapping", {
+          params: { ...rest, cursor: cursor ?? nextToken },
+          requestOptions
+        });
+        return { items: raw.items ?? [], nextToken: raw.nextCursor ?? raw.nextToken ?? null };
+      },
       params: { ...params }
     });
   }
   async listPage(params = {}, requestOptions) {
-    const raw = await this.transport.request(
-      "GET",
-      "/mapping",
-      { params, requestOptions }
-    );
-    return new Page(raw.items, raw.nextToken);
+    const { nextToken, cursor, ...rest } = params;
+    const raw = await this.transport.request("GET", "/mapping", {
+      params: { ...rest, cursor: cursor ?? nextToken },
+      requestOptions
+    });
+    return new Page(raw.items ?? [], raw.nextCursor ?? raw.nextToken ?? null);
   }
   async get(jobId, requestOptions) {
     return await this.transport.request("GET", `/mapping/${jobId}`, { requestOptions });
@@ -798,6 +1068,16 @@ var MappingResource = class extends Resource {
       requestOptions
     });
   }
+  // Trigger on-demand security-probe analysis on a completed mapping run.
+  // Returns the queue summary { message, probeCount }; poll the run / steps
+  // afterwards to see classified results land.
+  async probe(jobId, runId, requestOptions) {
+    return await this.transport.request(
+      "POST",
+      `/mapping/${jobId}/runs/${runId}/probe`,
+      { requestOptions }
+    );
+  }
   steps(jobId, params = {}, requestOptions) {
     return new Paginator({
       fetchPage: async (p) => await this.transport.request("GET", `/mapping/${jobId}/steps`, {
@@ -854,13 +1134,6 @@ var MappingResource = class extends Resource {
       { 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),
@@ -873,6 +1146,83 @@ var MappingResource = class extends Resource {
   }
 };
 
+// src/resources/missionTestConfigs.ts
+var MissionTestConfigsResource = class extends Resource {
+  list(params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => {
+        const { nextToken, cursor, ...rest } = p;
+        const raw = await this.transport.request("GET", "/testing/mission-test-configs", {
+          params: { ...rest, cursor: cursor ?? nextToken },
+          requestOptions
+        });
+        return { items: raw.items ?? [], nextToken: raw.nextCursor ?? raw.nextToken ?? null };
+      },
+      params: { ...params }
+    });
+  }
+  async listPage(params = {}, requestOptions) {
+    const { nextToken, cursor, ...rest } = params;
+    const raw = await this.transport.request("GET", "/testing/mission-test-configs", {
+      params: { ...rest, cursor: cursor ?? nextToken },
+      requestOptions
+    });
+    return new Page(raw.items ?? [], raw.nextCursor ?? raw.nextToken ?? null);
+  }
+  async create(body, requestOptions) {
+    return await this.transport.request("POST", "/testing/mission-test-configs", { body, requestOptions });
+  }
+  async get(id, requestOptions) {
+    return await this.transport.request("GET", `/testing/mission-test-configs/${id}`, { requestOptions });
+  }
+  async update(id, body, requestOptions) {
+    return await this.transport.request("PATCH", `/testing/mission-test-configs/${id}`, {
+      body,
+      requestOptions
+    });
+  }
+  async delete(id, requestOptions) {
+    await this.transport.request("DELETE", `/testing/mission-test-configs/${id}`, { requestOptions });
+  }
+  // Launch a mission test run from a saved config. The returned run is freeform-shaped.
+  async run(id, requestOptions) {
+    return await this.transport.request("POST", `/testing/mission-test-configs/${id}/runs`, { requestOptions });
+  }
+};
+
+// src/resources/missionTests.ts
+var MissionTestsResource = class extends Resource {
+  list(params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => await this.transport.request("GET", "/testing/mission-tests", { params: p, requestOptions }),
+      params: { ...params }
+    });
+  }
+  async listPage(params = {}, requestOptions) {
+    const raw = await this.transport.request(
+      "GET",
+      "/testing/mission-tests",
+      { params, requestOptions }
+    );
+    return new Page(raw.items, raw.nextToken);
+  }
+  async create(body, requestOptions) {
+    return await this.transport.request("POST", "/testing/mission-tests", { body, requestOptions });
+  }
+  // Returns 503 with code='CATALOG_NOT_READY' until the mission-tester service
+  // publishes its SSM payload. Callers can catch and retry, or fall back to a
+  // known-good default sector/mission/acceptance.
+  async getDefaults(requestOptions) {
+    return await this.transport.request("GET", "/testing/mission-tests/defaults", { requestOptions });
+  }
+  async get(id, requestOptions) {
+    return await this.transport.request("GET", `/testing/mission-tests/${id}`, { requestOptions });
+  }
+  async cancel(id, requestOptions) {
+    return await this.transport.request("POST", `/testing/mission-tests/${id}/cancel`, { requestOptions });
+  }
+};
+
 // src/resources/profiles.ts
 var ProfilesResource = class extends Resource {
   async create(body, requestOptions) {
@@ -1103,15 +1453,33 @@ var TestingRunsResource = class extends Resource {
   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 };
+        const { nextToken, cursor, ...rest } = p;
+        const raw = await this.transport.request("GET", "/testing/runs", {
+          params: { ...rest, cursor: cursor ?? nextToken },
+          requestOptions
+        });
+        return {
+          items: raw.runs ?? raw.items ?? [],
+          nextToken: raw.nextCursor ?? raw.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);
+    const { nextToken, cursor, ...rest } = params;
+    const raw = await this.transport.request("GET", "/testing/runs", {
+      params: { ...rest, cursor: cursor ?? nextToken },
+      requestOptions
+    });
+    return new Page(raw.runs ?? raw.items ?? [], raw.nextCursor ?? raw.nextToken ?? null);
+  }
+  /** GET /testing/runs/aggregate — grouped counts over test runs. */
+  async aggregate(params, requestOptions) {
+    return await this.transport.request("GET", "/testing/runs/aggregate", {
+      params,
+      requestOptions
+    });
   }
   async get(runId, requestOptions) {
     return await this.transport.request("GET", `/testing/runs/${runId}`, { requestOptions });
@@ -1137,6 +1505,24 @@ var TestingResource = class extends Resource {
     this.jobs = new TestingJobsResource(transport);
     this.runs = new TestingRunsResource(transport);
   }
+  /** Paginated, filtered list of test runs (alias for `testing.runs.list()`). */
+  listRuns(params = {}, requestOptions) {
+    return this.runs.list(params, requestOptions);
+  }
+  /** GET /testing/voices — operator-enabled voices a mission test may use. */
+  async listVoices(requestOptions) {
+    return await this.transport.request("GET", "/testing/voices", { requestOptions });
+  }
+  /** GET /testing/runs/aggregate — grouped counts over test runs. */
+  async aggregateRuns(params, requestOptions) {
+    return await this.runs.aggregate(params, requestOptions);
+  }
+  /** GET /testing/mission-test-runs/{id} — mission-strict run detail (no steps). */
+  async getMissionTestRun(id, requestOptions) {
+    return await this.transport.request("GET", `/testing/mission-test-runs/${id}`, {
+      requestOptions
+    });
+  }
 };
 
 // src/client.ts
@@ -1151,6 +1537,12 @@ var Nopaque = class {
   loadTesting;
   scheduler;
   enrichment;
+  missionTests;
+  missionTestConfigs;
+  compliance;
+  digitalTesting;
+  digitalTestConfigs;
+  digitalCompliance;
   transport;
   constructor(options = {}) {
     const config = resolveConfig(options);
@@ -1165,6 +1557,12 @@ var Nopaque = class {
     this.loadTesting = new LoadTestingResource(this.transport);
     this.scheduler = new SchedulerResource(this.transport);
     this.enrichment = new EnrichmentResource(this.transport);
+    this.missionTests = new MissionTestsResource(this.transport);
+    this.missionTestConfigs = new MissionTestConfigsResource(this.transport);
+    this.compliance = new ComplianceResource(this.transport);
+    this.digitalTesting = new DigitalTestingResource(this.transport);
+    this.digitalTestConfigs = new DigitalTestConfigsResource(this.transport);
+    this.digitalCompliance = new DigitalComplianceResource(this.transport);
   }
   close() {
   }