@attlaz/client 1.95.0 → 1.97.0

package/dist/Catalog/Service/CatalogEndpoint.js

@@ -1,3 +1,4 @@
+import { path } from '../../Http/Data/Path.js';
 import { QueryString } from '../../Http/Data/QueryString.js';
 import { Catalog } from '../Model/Catalog.js';
 import { Endpoint } from '../../Service/Endpoint.js';
@@ -15,7 +16,7 @@ export class CatalogEndpoint extends Endpoint {
     }
     /** The catalog with this id, or null. */
     async getById(catalogId) {
-        const result = await this.requestObject('/catalogs/' + catalogId.toString(), null, Catalog.parse, 'GET');
+        const result = await this.requestObject(path('/catalogs/:catalogId', { catalogId: catalogId.toString() }), null, Catalog.parse, 'GET');
         return result.getData();
     }
 }

package/dist/Catalog/Service/CatalogProductEndpoint.js

@@ -1,3 +1,4 @@
+import { path } from '../../Http/Data/Path.js';
 import { QueryString } from '../../Http/Data/QueryString.js';
 import { Endpoint } from '../../Service/Endpoint.js';
 import { CatalogProduct } from '../Model/CatalogProduct.js';
@@ -9,13 +10,13 @@ import { CatalogProduct } from '../Model/CatalogProduct.js';
  */
 export class CatalogProductEndpoint extends Endpoint {
     async getByCatalog(catalogId, pagination = null) {
-        const queryString = new QueryString('/catalogs/' + catalogId.toString() + '/products');
+        const queryString = new QueryString(path('/catalogs/:catalogId/products', { catalogId: catalogId.toString() }));
         queryString.addPagination(pagination);
         return await this.requestCollection(queryString, CatalogProduct.parse);
     }
     /** The product with this catalog identifier, or null. */
     async getByIdentifier(catalogId, identifier) {
-        const queryString = new QueryString('/catalogs/' + catalogId.toString() + '/products');
+        const queryString = new QueryString(path('/catalogs/:catalogId/products', { catalogId: catalogId.toString() }));
         queryString.set('identifier', identifier);
         const result = await this.requestCollection(queryString, CatalogProduct.parse);
         const products = result.getData();

package/dist/Client.d.ts

@@ -24,20 +24,20 @@ import { PlatformLanguageEndpoint } from './Service/PlatformLanguageEndpoint.js'
 import { ProjectEndpoint } from './Service/ProjectEndpoint.js';
 import { ProjectEnvironmentEndpoint } from './Service/ProjectEnvironmentEndpoint.js';
 import { ProviderTokenEndpoint } from './Service/ProviderTokenEndpoint.js';
-import { VendorProductEndpoint } from './Pulse/Service/VendorProductEndpoint.js';
-import { CrawlJobEndpoint } from './Pulse/Service/CrawlJobEndpoint.js';
+import { VendorProductEndpoint } from './MarketPulse/Service/VendorProductEndpoint.js';
+import { CrawlJobEndpoint } from './MarketPulse/Service/CrawlJobEndpoint.js';
 import { CatalogEndpoint } from './Catalog/Service/CatalogEndpoint.js';
-import { ProductMatchJobEndpoint } from './Pulse/Service/ProductMatchJobEndpoint.js';
-import { IndexJobEndpoint } from './Pulse/Service/IndexJobEndpoint.js';
-import { ProductMatchEndpoint } from './Pulse/Service/ProductMatchEndpoint.js';
-import { PulseCatalogProductEndpoint } from './Pulse/Service/PulseCatalogProductEndpoint.js';
-import { PriceAlertEndpoint } from './Pulse/Service/PriceAlertEndpoint.js';
-import { PricingEndpoint } from './Pulse/Service/PricingEndpoint.js';
-import { ProductGroupEndpoint } from './Pulse/Service/ProductGroupEndpoint.js';
+import { ProductMatchJobEndpoint } from './MarketPulse/Service/ProductMatchJobEndpoint.js';
+import { IndexJobEndpoint } from './MarketPulse/Service/IndexJobEndpoint.js';
+import { ProductMatchEndpoint } from './MarketPulse/Service/ProductMatchEndpoint.js';
+import { PulseCatalogProductEndpoint } from './MarketPulse/Service/PulseCatalogProductEndpoint.js';
+import { PriceAlertEndpoint } from './MarketPulse/Service/PriceAlertEndpoint.js';
+import { PricingEndpoint } from './MarketPulse/Service/PricingEndpoint.js';
+import { ProductGroupEndpoint } from './MarketPulse/Service/ProductGroupEndpoint.js';
 import { CatalogProductEndpoint } from './Catalog/Service/CatalogProductEndpoint.js';
-import { GenerateContentEndpoint } from './EnhanceData/Service/GenerateContentEndpoint.js';
-import { CompetitorEndpoint } from './Pulse/Service/CompetitorEndpoint.js';
-import { PulseStatisticsEndpoint } from './Pulse/Service/PulseStatisticsEndpoint.js';
+import { GenerateContentEndpoint } from './DataEnrichment/Service/GenerateContentEndpoint.js';
+import { CompetitorEndpoint } from './MarketPulse/Service/CompetitorEndpoint.js';
+import { PulseStatisticsEndpoint } from './MarketPulse/Service/PulseStatisticsEndpoint.js';
 import { QualityEndpoint } from './DataQuality/Service/QualityEndpoint.js';
 import { CatalogFeedEndpoint } from './FeedManagement/Service/CatalogFeedEndpoint.js';
 import { RunnerEndpoint } from './Service/RunnerEndpoint.js';

package/dist/Client.js

@@ -24,20 +24,20 @@ import { PlatformLanguageEndpoint } from './Service/PlatformLanguageEndpoint.js'
 import { ProjectEndpoint } from './Service/ProjectEndpoint.js';
 import { ProjectEnvironmentEndpoint } from './Service/ProjectEnvironmentEndpoint.js';
 import { ProviderTokenEndpoint } from './Service/ProviderTokenEndpoint.js';
-import { VendorProductEndpoint } from './Pulse/Service/VendorProductEndpoint.js';
-import { CrawlJobEndpoint } from './Pulse/Service/CrawlJobEndpoint.js';
+import { VendorProductEndpoint } from './MarketPulse/Service/VendorProductEndpoint.js';
+import { CrawlJobEndpoint } from './MarketPulse/Service/CrawlJobEndpoint.js';
 import { CatalogEndpoint } from './Catalog/Service/CatalogEndpoint.js';
-import { ProductMatchJobEndpoint } from './Pulse/Service/ProductMatchJobEndpoint.js';
-import { IndexJobEndpoint } from './Pulse/Service/IndexJobEndpoint.js';
-import { ProductMatchEndpoint } from './Pulse/Service/ProductMatchEndpoint.js';
-import { PulseCatalogProductEndpoint } from './Pulse/Service/PulseCatalogProductEndpoint.js';
-import { PriceAlertEndpoint } from './Pulse/Service/PriceAlertEndpoint.js';
-import { PricingEndpoint } from './Pulse/Service/PricingEndpoint.js';
-import { ProductGroupEndpoint } from './Pulse/Service/ProductGroupEndpoint.js';
+import { ProductMatchJobEndpoint } from './MarketPulse/Service/ProductMatchJobEndpoint.js';
+import { IndexJobEndpoint } from './MarketPulse/Service/IndexJobEndpoint.js';
+import { ProductMatchEndpoint } from './MarketPulse/Service/ProductMatchEndpoint.js';
+import { PulseCatalogProductEndpoint } from './MarketPulse/Service/PulseCatalogProductEndpoint.js';
+import { PriceAlertEndpoint } from './MarketPulse/Service/PriceAlertEndpoint.js';
+import { PricingEndpoint } from './MarketPulse/Service/PricingEndpoint.js';
+import { ProductGroupEndpoint } from './MarketPulse/Service/ProductGroupEndpoint.js';
 import { CatalogProductEndpoint } from './Catalog/Service/CatalogProductEndpoint.js';
-import { GenerateContentEndpoint } from './EnhanceData/Service/GenerateContentEndpoint.js';
-import { CompetitorEndpoint } from './Pulse/Service/CompetitorEndpoint.js';
-import { PulseStatisticsEndpoint } from './Pulse/Service/PulseStatisticsEndpoint.js';
+import { GenerateContentEndpoint } from './DataEnrichment/Service/GenerateContentEndpoint.js';
+import { CompetitorEndpoint } from './MarketPulse/Service/CompetitorEndpoint.js';
+import { PulseStatisticsEndpoint } from './MarketPulse/Service/PulseStatisticsEndpoint.js';
 import { QualityEndpoint } from './DataQuality/Service/QualityEndpoint.js';
 import { CatalogFeedEndpoint } from './FeedManagement/Service/CatalogFeedEndpoint.js';
 import { RunnerEndpoint } from './Service/RunnerEndpoint.js';

package/dist/{EnhanceData → DataEnrichment}/Service/GenerateContentEndpoint.js

@@ -1,3 +1,4 @@
+import { path } from '../../Http/Data/Path.js';
 import { QueryString } from '../../Http/Data/QueryString.js';
 import { Endpoint } from '../../Service/Endpoint.js';
 import { GenerateContentBatch } from '../Model/GenerateContentBatch.js';
@@ -9,13 +10,13 @@ import { GenerateContentBatch } from '../Model/GenerateContentBatch.js';
  */
 export class GenerateContentEndpoint extends Endpoint {
     async getBatches(projectId, pagination = null) {
-        const queryString = new QueryString('/projects/' + projectId + '/content-generation-batches');
+        const queryString = new QueryString(path('/projects/:projectId/content-generation-batches', { projectId }));
         queryString.addPagination(pagination);
         return await this.requestCollection(queryString, GenerateContentBatch.parse);
     }
     /** Queue a batch. The generated values become proposals to review, not direct writes. */
     async requestGeneration(projectId, data) {
-        const result = await this.requestObject('/projects/' + projectId + '/content-generation-batches', data, GenerateContentBatch.parse, 'POST');
+        const result = await this.requestObject(path('/projects/:projectId/content-generation-batches', { projectId }), data, GenerateContentBatch.parse, 'POST');
         return result.getData();
     }
 }

package/dist/DataQuality/Model/QualityDataset.d.ts

@@ -1,7 +1,7 @@
 import { ApiRecord } from '../../Model/ApiRecord.js';
 /**
  * A data-quality dataset: the set of entities being checked, and the problems found on them —
- * the `/data_quality/datasets` resource.
+ * the `/data-quality/datasets` resource.
  *
  * `autoCloseMode` decides what happens to an open problem that a later scan no longer reports.
  */

package/dist/DataQuality/Model/QualityDataset.js

@@ -1,6 +1,6 @@
 /**
  * A data-quality dataset: the set of entities being checked, and the problems found on them —
- * the `/data_quality/datasets` resource.
+ * the `/data-quality/datasets` resource.
  *
  * `autoCloseMode` decides what happens to an open problem that a later scan no longer reports.
  */

package/dist/DataQuality/Model/QualityEntity.d.ts

@@ -1,7 +1,7 @@
 import { ApiRecord } from '../../Model/ApiRecord.js';
 /**
  * One thing being checked in a dataset (a product, a category, …), with a rollup of the problems
- * currently open on it — the `/data_quality/datasets/:datasetId/entities` resource.
+ * currently open on it — the `/data-quality/datasets/:datasetId/entities` resource.
  *
  * `entityType` + `entityId` identify it in the source system; `id` is the dataset's own row.
  */

package/dist/DataQuality/Model/QualityEntity.js

@@ -1,6 +1,6 @@
 /**
  * One thing being checked in a dataset (a product, a category, …), with a rollup of the problems
- * currently open on it — the `/data_quality/datasets/:datasetId/entities` resource.
+ * currently open on it — the `/data-quality/datasets/:datasetId/entities` resource.
  *
  * `entityType` + `entityId` identify it in the source system; `id` is the dataset's own row.
  */

package/dist/DataQuality/Model/{QualitySuppression.d.ts → QualityEntityProblemSuppression.d.ts}

@@ -1,13 +1,13 @@
 import { ApiRecord } from '../../Model/ApiRecord.js';
 /**
  * A standing decision to ignore a problem code — the
- * `/data_quality/datasets/:datasetId/suppressions` resource.
+ * `/data-quality/datasets/:datasetId/entity-problem-suppressions` resource.
  *
  * With `entityType` and `entityId` set it covers that one entity; with both null it covers the code
  * across the whole dataset. Suppressed problems are still ingested but parked in `muted`, so they
  * stay out of the needs-attention list and out of every auto-close path without losing history.
  */
-export declare class QualitySuppression {
+export declare class QualityEntityProblemSuppression {
     id: string;
     code: string;
     /** Both null = the suppression applies to this code across the whole dataset. */
@@ -18,5 +18,5 @@ export declare class QualitySuppression {
     createdAt: Date | null;
     constructor(id: string, code: string);
     get isDatasetWide(): boolean;
-    static parse(raw: ApiRecord): QualitySuppression;
+    static parse(raw: ApiRecord): QualityEntityProblemSuppression;
 }

package/dist/DataQuality/Model/{QualitySuppression.js → QualityEntityProblemSuppression.js}

@@ -1,12 +1,12 @@
 /**
  * A standing decision to ignore a problem code — the
- * `/data_quality/datasets/:datasetId/suppressions` resource.
+ * `/data-quality/datasets/:datasetId/entity-problem-suppressions` resource.
  *
  * With `entityType` and `entityId` set it covers that one entity; with both null it covers the code
  * across the whole dataset. Suppressed problems are still ingested but parked in `muted`, so they
  * stay out of the needs-attention list and out of every auto-close path without losing history.
  */
-export class QualitySuppression {
+export class QualityEntityProblemSuppression {
     id;
     code;
     /** Both null = the suppression applies to this code across the whole dataset. */
@@ -23,7 +23,7 @@ export class QualitySuppression {
         return this.entityId === null;
     }
     static parse(raw) {
-        const suppression = new QualitySuppression(raw.id, raw.code);
+        const suppression = new QualityEntityProblemSuppression(raw.id, raw.code);
         suppression.entityType = raw.entity_type ?? null;
         // The API strips the `_id` suffix, so `entity_id` arrives as `entity`.
         suppression.entityId = raw.entity ?? null;

package/dist/DataQuality/Model/QualityEntityProblemSuppressionResult.d.ts

@@ -0,0 +1,6 @@
+import { QualityEntityProblemSuppression } from './QualityEntityProblemSuppression.js';
+/** What a new suppression did: the record itself, plus how many open problems it muted. */
+export type QualityEntityProblemSuppressionResult = {
+    suppression: QualityEntityProblemSuppression | null;
+    muted: number;
+};

package/dist/DataQuality/Model/QualityProblem.d.ts

@@ -1,7 +1,7 @@
 import { ApiRecord } from '../../Model/ApiRecord.js';
 /**
  * One quality issue found on an entity — the
- * `/data_quality/datasets/:datasetId/entities/:entityType/:entityId/problems` resource.
+ * `/data-quality/datasets/:datasetId/entities/:entityType/:entityId/problems` resource.
  *
  * `code` says what is wrong (the rule that fired) and `property` where; `channel` and `locale`
  * narrow it to one sales channel or language when the rule is scoped that way.

package/dist/DataQuality/Model/QualityProblem.js

@@ -1,6 +1,6 @@
 /**
  * One quality issue found on an entity — the
- * `/data_quality/datasets/:datasetId/entities/:entityType/:entityId/problems` resource.
+ * `/data-quality/datasets/:datasetId/entities/:entityType/:entityId/problems` resource.
  *
  * `code` says what is wrong (the rule that fired) and `property` where; `channel` and `locale`
  * narrow it to one sales channel or language when the rule is scoped that way.

package/dist/DataQuality/Model/QualityProblemDefinition.d.ts

@@ -1,6 +1,6 @@
 import { ApiRecord } from '../../Model/ApiRecord.js';
 /**
- * The catalogue entry behind a problem code — the `/data_quality/definitions` resource.
+ * The catalogue entry behind a problem code — the `/data-quality/definitions` resource.
  *
  * A code is a machine key (`verlichting.ean_invalid_checkdigit`); the definition is what makes it
  * readable, so anything showing a code to a user should resolve it here. Definitions are either

package/dist/DataQuality/Model/QualityProblemDefinition.js

@@ -1,5 +1,5 @@
 /**
- * The catalogue entry behind a problem code — the `/data_quality/definitions` resource.
+ * The catalogue entry behind a problem code — the `/data-quality/definitions` resource.
  *
  * A code is a machine key (`verlichting.ean_invalid_checkdigit`); the definition is what makes it
  * readable, so anything showing a code to a user should resolve it here. Definitions are either

package/dist/DataQuality/Model/QualityProblemEvent.d.ts

@@ -1,7 +1,7 @@
 import { ApiRecord } from '../../Model/ApiRecord.js';
 /**
  * One transition of a single problem — the
- * `/data_quality/datasets/:datasetId/entities/:entityType/:entityId/problems/:code/events` resource.
+ * `/data-quality/datasets/:datasetId/entities/:entityType/:entityId/problems/:code/events` resource.
  *
  * A problem is reported once and then re-reported by every later scan; only the transitions are
  * recorded, so the timeline stays short: `reported` when it first appears, `resolved` when a scan

package/dist/DataQuality/Model/QualityProblemEvent.js

@@ -1,6 +1,6 @@
 /**
  * One transition of a single problem — the
- * `/data_quality/datasets/:datasetId/entities/:entityType/:entityId/problems/:code/events` resource.
+ * `/data-quality/datasets/:datasetId/entities/:entityType/:entityId/problems/:code/events` resource.
  *
  * A problem is reported once and then re-reported by every later scan; only the transitions are
  * recorded, so the timeline stays short: `reported` when it first appears, `resolved` when a scan

package/dist/DataQuality/Model/QualityReportEntity.d.ts

@@ -0,0 +1,31 @@
+import { QualityReportProblem } from './QualityReportProblem.js';
+/**
+ * One entity being reported on: its identity, optionally what it is, and what was found.
+ *
+ * `entityType` + `entityId` are the natural key within the dataset — an entity is created on first
+ * report, so there is nothing to register up front. `name`, `url` and `imageUrl` are optional: send
+ * them and the dashboard can show a recognisable row instead of a bare identifier.
+ *
+ * `passed` carries codes that were *checked and found clean*. That is what lets the platform close
+ * a problem that is no longer there — an entity reported with no problems and no `passed` codes says
+ * nothing about the codes it was previously failing.
+ */
+export declare class QualityReportEntity {
+    entityType: string;
+    entityId: string;
+    name: string | null;
+    url: string | null;
+    imageUrl: string | null;
+    data: Record<string, unknown> | null;
+    problems: QualityReportProblem[];
+    passed: string[];
+    constructor(entityType: string, entityId: string);
+    /**
+     * The snake_case wire shape.
+     *
+     * Built explicitly, and sent with `_formatted: true`, because the client's key formatter
+     * snake_cases keys *and strips a trailing `_id`* — it would turn `entity_id` into `entity`, which
+     * the report endpoint rejects. See Endpoint.prepareParameters().
+     */
+    toPayload(): Record<string, unknown>;
+}

package/dist/DataQuality/Model/QualityReportEntity.js

@@ -0,0 +1,44 @@
+/**
+ * One entity being reported on: its identity, optionally what it is, and what was found.
+ *
+ * `entityType` + `entityId` are the natural key within the dataset — an entity is created on first
+ * report, so there is nothing to register up front. `name`, `url` and `imageUrl` are optional: send
+ * them and the dashboard can show a recognisable row instead of a bare identifier.
+ *
+ * `passed` carries codes that were *checked and found clean*. That is what lets the platform close
+ * a problem that is no longer there — an entity reported with no problems and no `passed` codes says
+ * nothing about the codes it was previously failing.
+ */
+export class QualityReportEntity {
+    entityType;
+    entityId;
+    name = null;
+    url = null;
+    imageUrl = null;
+    data = null;
+    problems = [];
+    passed = [];
+    constructor(entityType, entityId) {
+        this.entityType = entityType;
+        this.entityId = entityId;
+    }
+    /**
+     * The snake_case wire shape.
+     *
+     * Built explicitly, and sent with `_formatted: true`, because the client's key formatter
+     * snake_cases keys *and strips a trailing `_id`* — it would turn `entity_id` into `entity`, which
+     * the report endpoint rejects. See Endpoint.prepareParameters().
+     */
+    toPayload() {
+        return {
+            entity_type: this.entityType,
+            entity_id: this.entityId,
+            name: this.name,
+            url: this.url,
+            image_url: this.imageUrl,
+            data: this.data,
+            problems: this.problems.map((problem) => problem.toPayload()),
+            passed: this.passed,
+        };
+    }
+}

package/dist/DataQuality/Model/QualityReportProblem.d.ts

@@ -0,0 +1,22 @@
+/**
+ * One problem found on one entity, as sent to the report endpoint.
+ *
+ * `code` is the machine key the problem definition hangs off (`shop.ean_invalid_checkdigit`);
+ * `property` is what the problem is about (`ean`, `name`, `image`). Severity is optional: leave it
+ * null and the platform applies the definition's default.
+ */
+export declare class QualityReportProblem {
+    code: string;
+    property: string;
+    severity: string | null;
+    note: string | null;
+    data: Record<string, unknown> | null;
+    channel: string | null;
+    locale: string | null;
+    constructor(code: string, property: string);
+    /**
+     * The snake_case wire shape. Built here rather than left to the client's key formatter, which
+     * would rewrite the keys — see QualityReportEntity.toPayload().
+     */
+    toPayload(): Record<string, unknown>;
+}

package/dist/DataQuality/Model/QualityReportProblem.js

@@ -0,0 +1,35 @@
+/**
+ * One problem found on one entity, as sent to the report endpoint.
+ *
+ * `code` is the machine key the problem definition hangs off (`shop.ean_invalid_checkdigit`);
+ * `property` is what the problem is about (`ean`, `name`, `image`). Severity is optional: leave it
+ * null and the platform applies the definition's default.
+ */
+export class QualityReportProblem {
+    code;
+    property;
+    severity = null;
+    note = null;
+    data = null;
+    channel = null;
+    locale = null;
+    constructor(code, property) {
+        this.code = code;
+        this.property = property;
+    }
+    /**
+     * The snake_case wire shape. Built here rather than left to the client's key formatter, which
+     * would rewrite the keys — see QualityReportEntity.toPayload().
+     */
+    toPayload() {
+        return {
+            code: this.code,
+            property: this.property,
+            severity: this.severity,
+            note: this.note,
+            data: this.data,
+            channel: this.channel,
+            locale: this.locale,
+        };
+    }
+}

package/dist/DataQuality/Model/QualityReportResult.d.ts

@@ -0,0 +1,9 @@
+import { ApiRecord } from '../../Model/ApiRecord.js';
+/** What a report call did: how much was ingested, and how much it resolved. */
+export declare class QualityReportResult {
+    entityCount: number;
+    problemCount: number;
+    /** Problems closed because the reporter said the code now passes on that entity. */
+    resolvedCount: number;
+    static parse(raw: ApiRecord): QualityReportResult;
+}

package/dist/DataQuality/Model/QualityReportResult.js

@@ -0,0 +1,14 @@
+/** What a report call did: how much was ingested, and how much it resolved. */
+export class QualityReportResult {
+    entityCount = 0;
+    problemCount = 0;
+    /** Problems closed because the reporter said the code now passes on that entity. */
+    resolvedCount = 0;
+    static parse(raw) {
+        const result = new QualityReportResult();
+        result.entityCount = Number(raw.entity_count ?? 0);
+        result.problemCount = Number(raw.problem_count ?? 0);
+        result.resolvedCount = Number(raw.resolved_count ?? 0);
+        return result;
+    }
+}

package/dist/DataQuality/Model/QualityScan.d.ts

@@ -0,0 +1,19 @@
+import { ApiRecord } from '../../Model/ApiRecord.js';
+/**
+ * One reporting run against a dataset — the `/data-quality/datasets/:datasetId/scans` resource.
+ *
+ * A scan brackets the problems a reporter sends: open one, report into it, complete it. Completing
+ * is what lets the platform resolve problems that were not re-reported, so a scan that is opened and
+ * never completed leaves stale problems open.
+ */
+export declare class QualityScan {
+    id: string;
+    dataset: string;
+    /** The check pack this run covers; scopes what auto-close is allowed to resolve. */
+    pack: string | null;
+    status: string;
+    startedAt: Date | null;
+    completedAt: Date | null;
+    constructor(id: string, dataset: string, status: string);
+    static parse(raw: ApiRecord): QualityScan;
+}

package/dist/DataQuality/Model/QualityScan.js

@@ -0,0 +1,28 @@
+/**
+ * One reporting run against a dataset — the `/data-quality/datasets/:datasetId/scans` resource.
+ *
+ * A scan brackets the problems a reporter sends: open one, report into it, complete it. Completing
+ * is what lets the platform resolve problems that were not re-reported, so a scan that is opened and
+ * never completed leaves stale problems open.
+ */
+export class QualityScan {
+    id;
+    dataset;
+    /** The check pack this run covers; scopes what auto-close is allowed to resolve. */
+    pack = null;
+    status;
+    startedAt = null;
+    completedAt = null;
+    constructor(id, dataset, status) {
+        this.id = id;
+        this.dataset = dataset;
+        this.status = status;
+    }
+    static parse(raw) {
+        const scan = new QualityScan(raw.id, raw.dataset, raw.status);
+        scan.pack = raw.pack ?? null;
+        scan.startedAt = raw.started_at ? new Date(raw.started_at) : null;
+        scan.completedAt = raw.completed_at ? new Date(raw.completed_at) : null;
+        return scan;
+    }
+}

package/dist/DataQuality/Service/QualityEndpoint.d.ts

@@ -5,14 +5,17 @@ import { QualityFilterOptions } from '../Model/QualityFilterOptions.js';
 import { QualityProblem } from '../Model/QualityProblem.js';
 import { QualityProblemDefinition } from '../Model/QualityProblemDefinition.js';
 import { QualityProblemEvent } from '../Model/QualityProblemEvent.js';
+import { QualityReportEntity } from '../Model/QualityReportEntity.js';
+import { QualityReportResult } from '../Model/QualityReportResult.js';
+import { QualityScan } from '../Model/QualityScan.js';
 import { QualitySummary } from '../Model/QualitySummary.js';
-import { QualitySuppression } from '../Model/QualitySuppression.js';
-import { QualitySuppressionResult } from '../Model/QualitySuppressionResult.js';
+import { QualityEntityProblemSuppression } from '../Model/QualityEntityProblemSuppression.js';
+import { QualityEntityProblemSuppressionResult } from '../Model/QualityEntityProblemSuppressionResult.js';
 import { CursorPagination } from '../../Model/Pagination/CursorPagination.js';
 import { CollectionResult } from '../../Model/Result/CollectionResult.js';
 import { Endpoint } from '../../Service/Endpoint.js';
 /**
- * Data Quality — `/data_quality/datasets`. A dataset holds the entities being checked and the
+ * Data Quality — `/data-quality/datasets`. A dataset holds the entities being checked and the
  * problems open on them.
  */
 export declare class QualityEndpoint extends Endpoint {
@@ -29,6 +32,60 @@ export declare class QualityEndpoint extends Endpoint {
     getEntityProblems(datasetId: string, entityType: string, entityId: string, includeSuppressed?: boolean): Promise<CollectionResult<QualityProblem>>;
     /** The transition timeline for one problem, oldest first. */
     getProblemEvents(datasetId: string, entityType: string, entityId: string, code: string): Promise<CollectionResult<QualityProblemEvent>>;
+    /**
+     * Open a scan: the bracket a reporter puts around one run of checks.
+     *
+     * `pack` names the group of checks this run covers. It scopes what completing the scan is allowed
+     * to close, so a partial run cannot resolve problems it never looked at.
+     */
+    openScan(datasetId: string, pack?: string | null): Promise<QualityScan>;
+    /**
+     * Report what an open scan found. Safe to call repeatedly to send entities in batches.
+     *
+     * Entities are created on first report — there is nothing to register up front.
+     *
+     * **Batch size**: the API caps a request body at 512 KB (the Gateway rejects over 1 MB before it
+     * even arrives), and an entity carrying one problem is roughly 250-300 bytes of JSON — so keep
+     * batches to a low four figures of entities. An oversize request comes back as `413` with error
+     * code `payload_too_large`. Send several batches into the same scan rather than one large one.
+     */
+    reportToScan(datasetId: string, scanId: string, entities: QualityReportEntity[]): Promise<QualityReportResult>;
+    /**
+     * Close the scan, resolving problems the run covered but did not re-report. Returns how many were
+     * resolved.
+     *
+     * Skipping this leaves problems open that the reporter has already stopped finding.
+     */
+    completeScan(datasetId: string, scanId: string): Promise<number>;
+    /**
+     * Open a scan, report everything and complete it in one call — for a reporter that already has
+     * the full picture in memory and does not need to stream it in batches.
+     *
+     * Everything goes in one request, so this is bounded by the API's 512 KB body cap — a few
+     * thousand entities at most. Beyond that use `openScan` / `reportToScan` / `completeScan`, which
+     * can send as many batches as you like into one scan.
+     */
+    reportProblems(datasetId: string, entities: QualityReportEntity[], pack?: string | null): Promise<QualityReportResult>;
+    /**
+     * Both report routes take the same already-snake_cased body and return the same counts.
+     *
+     * `_formatted: true` sends the body verbatim. Without it the client's key formatter would rewrite
+     * every key and strip the trailing `_id` from `entity_id`, which the endpoint requires.
+     */
+    private postReport;
+    /**
+     * A write that came back with nothing — the base Endpoint maps a 404 to null data, and also
+     * returns null when the response cannot be parsed.
+     *
+     * Reads may legitimately answer "no such thing" with null, but a write cannot: returning a zero
+     * count here would be indistinguishable from a report that genuinely changed nothing, and a
+     * reporter would log success while its problems went nowhere.
+     *
+     * The message names both causes because the API cannot yet tell them apart — a missing dataset
+     * and a path that no longer exists (a reporter still on `/data_quality/`) both come back as a
+     * bare 404. Once the API sets an error `code`, branch on that instead.
+     */
+    private static writeFailed;
     /** Clear an entity's problems so the next scan starts from scratch; returns how many were removed. */
     resetEntity(datasetId: string, entityType: string, entityId: string): Promise<number>;
     getFilterOptions(datasetId: string): Promise<QualityFilterOptions>;
@@ -40,18 +97,18 @@ export declare class QualityEndpoint extends Endpoint {
      * have open problems, so a fully suppressed or resolved code has no label there.
      */
     getDefinitions(projectId: string, pack?: string | null): Promise<CollectionResult<QualityProblemDefinition>>;
-    getSuppressions(datasetId: string): Promise<CollectionResult<QualitySuppression>>;
+    getEntityProblemSuppressions(datasetId: string): Promise<CollectionResult<QualityEntityProblemSuppression>>;
     /**
      * Suppress a code, either on one entity or — with both entity fields omitted — across the whole
      * dataset. Also mutes the matching problems that are already open, so suppressing acts on what
      * is there rather than only on future scans.
      */
-    createSuppression(datasetId: string, suppression: {
+    createEntityProblemSuppression(datasetId: string, suppression: {
         code: string;
         entityType?: string | null;
         entityId?: string | null;
         reason?: string | null;
-    }): Promise<QualitySuppressionResult>;
+    }): Promise<QualityEntityProblemSuppressionResult>;
     /** Lift a suppression; returns how many muted problems were returned to the open list. */
-    deleteSuppression(datasetId: string, suppressionId: string): Promise<number>;
+    deleteEntityProblemSuppression(datasetId: string, entityProblemSuppressionId: string): Promise<number>;
 }