@attlaz/client 1.96.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/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,6 +5,9 @@ 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 { QualityEntityProblemSuppression } from '../Model/QualityEntityProblemSuppression.js';
 import { QualityEntityProblemSuppressionResult } from '../Model/QualityEntityProblemSuppressionResult.js';
@@ -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>;

package/dist/DataQuality/Service/QualityEndpoint.js

@@ -1,9 +1,14 @@
+import { path } from '../../Http/Data/Path.js';
+import { HttpStatus } from '../../Http/HttpStatus.js';
 import { QueryString } from '../../Http/Data/QueryString.js';
+import { ApiError } from '../../Model/Error/ApiError.js';
 import { QualityDataset } from '../Model/QualityDataset.js';
 import { QualityEntity } from '../Model/QualityEntity.js';
 import { QualityProblem } from '../Model/QualityProblem.js';
 import { QualityProblemDefinition } from '../Model/QualityProblemDefinition.js';
 import { QualityProblemEvent } from '../Model/QualityProblemEvent.js';
+import { QualityReportResult } from '../Model/QualityReportResult.js';
+import { QualityScan } from '../Model/QualityScan.js';
 import { QualityEntityProblemSuppression } from '../Model/QualityEntityProblemSuppression.js';
 import { Endpoint } from '../../Service/Endpoint.js';
 /**
@@ -18,7 +23,7 @@ export class QualityEndpoint extends Endpoint {
         return await this.requestCollection(queryString, QualityDataset.parse);
     }
     async getDataset(datasetId) {
-        const result = await this.requestObject('/data-quality/datasets/' + datasetId, null, QualityDataset.parse, 'GET');
+        const result = await this.requestObject(path('/data-quality/datasets/:datasetId', { datasetId }), null, QualityDataset.parse, 'GET');
         return result.getData();
     }
     async createDataset(projectId, name, autoCloseMode = null) {
@@ -31,14 +36,14 @@ export class QualityEndpoint extends Endpoint {
     }
     async updateDataset(datasetId, changes) {
         // camelCase keys are snake_cased by the base Endpoint (autoCloseMode -> auto_close_mode).
-        const result = await this.requestObject('/data-quality/datasets/' + datasetId, changes, QualityDataset.parse, 'PATCH');
+        const result = await this.requestObject(path('/data-quality/datasets/:datasetId', { datasetId }), changes, QualityDataset.parse, 'PATCH');
         return result.getData();
     }
     async deleteDataset(datasetId) {
-        await this.requestObject('/data-quality/datasets/' + datasetId, null, (raw) => raw, 'DELETE');
+        await this.requestObject(path('/data-quality/datasets/:datasetId', { datasetId }), null, (raw) => raw, 'DELETE');
     }
     async getEntities(datasetId, pagination = null, filters = {}) {
-        const queryString = new QueryString('/data-quality/datasets/' + datasetId + '/entities');
+        const queryString = new QueryString(path('/data-quality/datasets/:datasetId/entities', { datasetId }));
         if (filters.entityType) {
             queryString.set('entity_type', filters.entityType);
         }
@@ -62,9 +67,7 @@ export class QualityEndpoint extends Endpoint {
     }
     /** Suppressed problems are hidden unless `includeSuppressed` is set. */
     async getEntityProblems(datasetId, entityType, entityId, includeSuppressed = false) {
-        const queryString = new QueryString('/data-quality/datasets/' + datasetId
-            + '/entities/' + encodeURIComponent(entityType)
-            + '/' + encodeURIComponent(entityId) + '/problems');
+        const queryString = new QueryString(path('/data-quality/datasets/:datasetId/entities/:entityType/:entityId/problems', { datasetId, entityType, entityId }));
         if (includeSuppressed) {
             queryString.set('include_suppressed', 'true');
         }
@@ -72,22 +75,105 @@ export class QualityEndpoint extends Endpoint {
     }
     /** The transition timeline for one problem, oldest first. */
     async getProblemEvents(datasetId, entityType, entityId, code) {
-        const path = '/data-quality/datasets/' + datasetId
-            + '/entities/' + encodeURIComponent(entityType)
-            + '/' + encodeURIComponent(entityId)
-            + '/problems/' + encodeURIComponent(code) + '/events';
-        return await this.requestCollection(path, QualityProblemEvent.parse);
+        const requestPath = path('/data-quality/datasets/:datasetId/entities/:entityType/:entityId/problems/:code/events', { datasetId, entityType, entityId, code });
+        return await this.requestCollection(requestPath, QualityProblemEvent.parse);
+    }
+    // ---- Ingest ----
+    /**
+     * 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.
+     */
+    async openScan(datasetId, pack = null) {
+        const requestPath = path('/data-quality/datasets/:datasetId/scans', { datasetId });
+        const result = await this.requestObject(requestPath, { pack: pack }, QualityScan.parse, 'POST');
+        const scan = result.getData();
+        if (scan === null) {
+            throw QualityEndpoint.writeFailed(requestPath);
+        }
+        return scan;
+    }
+    /**
+     * 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.
+     */
+    async reportToScan(datasetId, scanId, entities) {
+        return await this.postReport(path('/data-quality/datasets/:datasetId/scans/:scanId/report', { datasetId, scanId }), { entities: entities.map((entity) => entity.toPayload()) });
+    }
+    /**
+     * 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.
+     */
+    async completeScan(datasetId, scanId) {
+        const requestPath = path('/data-quality/datasets/:datasetId/scans/:scanId/complete', { datasetId, scanId });
+        const result = await this.requestObject(requestPath, {}, (raw) => ({ resolved: Number(raw.resolved ?? 0) }), 'POST');
+        const data = result.getData();
+        if (data === null) {
+            throw QualityEndpoint.writeFailed(requestPath);
+        }
+        return data.resolved;
+    }
+    /**
+     * 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.
+     */
+    async reportProblems(datasetId, entities, pack = null) {
+        return await this.postReport(path('/data-quality/datasets/:datasetId/problems', { datasetId }), {
+            pack: pack,
+            entities: entities.map((entity) => entity.toPayload()),
+        });
+    }
+    /**
+     * 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.
+     */
+    async postReport(requestPath, body) {
+        const result = await this.requestObject(requestPath, { ...body, _formatted: true }, QualityReportResult.parse, 'POST');
+        const reportResult = result.getData();
+        if (reportResult === null) {
+            throw QualityEndpoint.writeFailed(requestPath);
+        }
+        return reportResult;
+    }
+    /**
+     * 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.
+     */
+    static writeFailed(requestPath) {
+        return new ApiError('Data Quality write to `' + requestPath + '` returned nothing. Either the dataset or scan does not exist, '
+            + 'or the endpoint does not — check the id, and that the client version matches the API.', HttpStatus.HTTP_NOTFOUND);
     }
     /** Clear an entity's problems so the next scan starts from scratch; returns how many were removed. */
     async resetEntity(datasetId, entityType, entityId) {
-        const path = '/data-quality/datasets/' + datasetId
-            + '/entities/' + encodeURIComponent(entityType)
-            + '/' + encodeURIComponent(entityId) + '/reset';
-        const result = await this.requestObject(path, {}, (raw) => ({ deleted: raw.deleted ?? 0 }), 'POST');
+        const requestPath = path('/data-quality/datasets/:datasetId/entities/:entityType/:entityId/reset', { datasetId, entityType, entityId });
+        const result = await this.requestObject(requestPath, {}, (raw) => ({ deleted: raw.deleted ?? 0 }), 'POST');
         return result.getData()?.deleted ?? 0;
     }
     async getFilterOptions(datasetId) {
-        const result = await this.requestObject('/data-quality/datasets/' + datasetId + '/filter-options', null, (raw) => ({
+        const result = await this.requestObject(path('/data-quality/datasets/:datasetId/filter-options', { datasetId }), null, (raw) => ({
             entityTypes: raw.entity_types ?? [],
             properties: raw.properties ?? [],
             codes: (raw.codes ?? []).map((row) => ({
@@ -100,7 +186,7 @@ export class QualityEndpoint extends Endpoint {
     }
     /** Both groupings in one call: `counts` by (property, severity) and `codes` for the fix cards. */
     async getSummary(datasetId) {
-        const result = await this.requestObject('/data-quality/datasets/' + datasetId + '/summary', null, (raw) => ({
+        const result = await this.requestObject(path('/data-quality/datasets/:datasetId/summary', { datasetId }), null, (raw) => ({
             counts: (raw.counts ?? []).map((row) => ({
                 property: row.property,
                 severity: row.severity,
@@ -134,7 +220,7 @@ export class QualityEndpoint extends Endpoint {
     }
     // ---- Suppressions ----
     async getEntityProblemSuppressions(datasetId) {
-        return await this.requestCollection('/data-quality/datasets/' + datasetId + '/entity-problem-suppressions', QualityEntityProblemSuppression.parse);
+        return await this.requestCollection(path('/data-quality/datasets/:datasetId/entity-problem-suppressions', { datasetId }), QualityEntityProblemSuppression.parse);
     }
     /**
      * Suppress a code, either on one entity or — with both entity fields omitted — across the whole
@@ -154,7 +240,7 @@ export class QualityEndpoint extends Endpoint {
             entity: suppression.entityId ?? null,
             reason: suppression.reason ?? null,
         };
-        const result = await this.requestObject('/data-quality/datasets/' + datasetId + '/entity-problem-suppressions', body, (raw) => ({
+        const result = await this.requestObject(path('/data-quality/datasets/:datasetId/entity-problem-suppressions', { datasetId }), body, (raw) => ({
             suppression: raw.id ? QualityEntityProblemSuppression.parse(raw) : null,
             muted: Number(raw.muted ?? 0),
         }), 'POST');
@@ -162,7 +248,7 @@ export class QualityEndpoint extends Endpoint {
     }
     /** Lift a suppression; returns how many muted problems were returned to the open list. */
     async deleteEntityProblemSuppression(datasetId, entityProblemSuppressionId) {
-        const result = await this.requestObject('/data-quality/datasets/' + datasetId + '/entity-problem-suppressions/' + entityProblemSuppressionId, null, (raw) => ({ reopened: Number(raw.reopened ?? 0) }), 'DELETE');
+        const result = await this.requestObject(path('/data-quality/datasets/:datasetId/entity-problem-suppressions/:entityProblemSuppressionId', { datasetId, entityProblemSuppressionId }), null, (raw) => ({ reopened: Number(raw.reopened ?? 0) }), 'DELETE');
         return result.getData()?.reopened ?? 0;
     }
 }

package/dist/FeedManagement/Service/CatalogFeedEndpoint.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 { CatalogFeed } from '../Model/CatalogFeed.js';
@@ -9,7 +10,7 @@ import { CatalogFeed } from '../Model/CatalogFeed.js';
  */
 export class CatalogFeedEndpoint extends Endpoint {
     async getByCatalog(catalogId, pagination = null, expand = []) {
-        const queryString = new QueryString('/catalogs/' + catalogId.toString() + '/feeds');
+        const queryString = new QueryString(path('/catalogs/:catalogId/feeds', { catalogId: catalogId.toString() }));
         if (expand.length > 0) {
             queryString.set('expand', expand);
         }