@attlaz/client 1.88.0 → 1.90.0

package/dist/Pulse/Service/IndexJobEndpoint.d.ts

@@ -0,0 +1,20 @@
+import { CatalogId } from '../../Catalog/Model/CatalogId.js';
+import { CursorPagination } from '../../Model/Pagination/CursorPagination.js';
+import { CollectionResult } from '../../Model/Result/CollectionResult.js';
+import { Endpoint } from '../../Service/Endpoint.js';
+import { IndexJob } from '../Model/IndexJob.js';
+import { VendorStatus } from '../Model/VendorStatus.js';
+/**
+ * Market Pulse index jobs — building the embeddings a competitor's products must have before they
+ * can be matched — and the resulting per-vendor freshness status.
+ */
+export declare class IndexJobEndpoint extends Endpoint {
+    /** Index jobs across every competitor of a catalog, newest first. */
+    getByCatalog(catalogId: CatalogId | string, pagination?: CursorPagination | null): Promise<CollectionResult<IndexJob>>;
+    /** Index jobs of one competitor. */
+    getByVendor(catalogId: CatalogId | string, vendorId: string, pagination?: CursorPagination | null): Promise<CollectionResult<IndexJob>>;
+    /** Queue a re-index of a competitor's products, so later matching sees current data. */
+    requestReindex(catalogId: CatalogId | string, vendorId: string): Promise<void>;
+    /** How fresh a competitor's index and matches are, plus any match job running right now. */
+    getVendorStatus(catalogId: CatalogId | string, vendorId: string): Promise<VendorStatus | null>;
+}

package/dist/Pulse/Service/IndexJobEndpoint.js

@@ -0,0 +1,31 @@
+import { QueryString } from '../../Http/Data/QueryString.js';
+import { Endpoint } from '../../Service/Endpoint.js';
+import { IndexJob } from '../Model/IndexJob.js';
+import { VendorStatus } from '../Model/VendorStatus.js';
+/**
+ * Market Pulse index jobs — building the embeddings a competitor's products must have before they
+ * can be matched — and the resulting per-vendor freshness status.
+ */
+export class IndexJobEndpoint extends Endpoint {
+    /** Index jobs across every competitor of a catalog, newest first. */
+    async getByCatalog(catalogId, pagination = null) {
+        const queryString = new QueryString('/pulse/catalogs/' + catalogId.toString() + '/index-jobs');
+        queryString.addPagination(pagination);
+        return await this.requestCollection(queryString, IndexJob.parse);
+    }
+    /** Index jobs of one competitor. */
+    async getByVendor(catalogId, vendorId, pagination = null) {
+        const queryString = new QueryString('/pulse/catalogs/' + catalogId.toString() + '/vendors/' + vendorId + '/index-jobs');
+        queryString.addPagination(pagination);
+        return await this.requestCollection(queryString, IndexJob.parse);
+    }
+    /** Queue a re-index of a competitor's products, so later matching sees current data. */
+    async requestReindex(catalogId, vendorId) {
+        await this.requestObject('/pulse/catalogs/' + catalogId.toString() + '/vendors/' + vendorId + '/reindex', {}, (raw) => raw, 'POST');
+    }
+    /** How fresh a competitor's index and matches are, plus any match job running right now. */
+    async getVendorStatus(catalogId, vendorId) {
+        const result = await this.requestObject('/pulse/catalogs/' + catalogId.toString() + '/vendors/' + vendorId + '/status', null, VendorStatus.parse, 'GET');
+        return result.getData();
+    }
+}

package/dist/Pulse/Service/PriceAlertEndpoint.d.ts

@@ -0,0 +1,31 @@
+import { CatalogId } from '../../Catalog/Model/CatalogId.js';
+import { CursorPagination } from '../../Model/Pagination/CursorPagination.js';
+import { CollectionResult } from '../../Model/Result/CollectionResult.js';
+import { Endpoint } from '../../Service/Endpoint.js';
+import { PriceAlertConfig } from '../Model/PriceAlertConfig.js';
+import { PriceAlertEvent } from '../Model/PriceAlertEvent.js';
+/** Fields accepted when creating an alert; camelCase keys are snake_cased by the base Endpoint. */
+export type PriceAlertConfigData = {
+    name: string;
+    conditionType: string;
+    conditionParams?: Record<string, unknown>;
+    productGroup?: string | null;
+    channelId: string;
+    isActive?: boolean;
+};
+/**
+ * Price alerts — the standing rules (`/pulse/price-alert-configs`) and the events they produce.
+ */
+export declare class PriceAlertEndpoint extends Endpoint {
+    getConfigs(catalogId: CatalogId | string, pagination?: CursorPagination | null): Promise<CollectionResult<PriceAlertConfig>>;
+    getConfig(alertConfigId: string): Promise<PriceAlertConfig | null>;
+    createConfig(catalogId: CatalogId | string, data: PriceAlertConfigData): Promise<PriceAlertConfig | null>;
+    updateConfig(alertConfigId: string, data: Partial<PriceAlertConfigData>): Promise<PriceAlertConfig | null>;
+    deleteConfig(alertConfigId: string): Promise<void>;
+    getEvents(alertConfigId: string, pagination?: CursorPagination | null): Promise<CollectionResult<PriceAlertEvent>>;
+    /**
+     * Record that someone has dealt with an event; it stays in the list. The API stamps who and
+     * when from the session, so the request carries no body.
+     */
+    acknowledgeEvent(alertEventId: string): Promise<PriceAlertEvent | null>;
+}

package/dist/Pulse/Service/PriceAlertEndpoint.js

@@ -0,0 +1,42 @@
+import { QueryString } from '../../Http/Data/QueryString.js';
+import { Endpoint } from '../../Service/Endpoint.js';
+import { PriceAlertConfig } from '../Model/PriceAlertConfig.js';
+import { PriceAlertEvent } from '../Model/PriceAlertEvent.js';
+/**
+ * Price alerts — the standing rules (`/pulse/price-alert-configs`) and the events they produce.
+ */
+export class PriceAlertEndpoint extends Endpoint {
+    async getConfigs(catalogId, pagination = null) {
+        const queryString = new QueryString('/pulse/catalogs/' + catalogId.toString() + '/price-alert-configs');
+        queryString.addPagination(pagination);
+        return await this.requestCollection(queryString, PriceAlertConfig.parse);
+    }
+    async getConfig(alertConfigId) {
+        const result = await this.requestObject('/pulse/price-alert-configs/' + alertConfigId, null, PriceAlertConfig.parse, 'GET');
+        return result.getData();
+    }
+    async createConfig(catalogId, data) {
+        const result = await this.requestObject('/pulse/catalogs/' + catalogId.toString() + '/price-alert-configs', data, PriceAlertConfig.parse, 'POST');
+        return result.getData();
+    }
+    async updateConfig(alertConfigId, data) {
+        const result = await this.requestObject('/pulse/price-alert-configs/' + alertConfigId, data, PriceAlertConfig.parse, 'PATCH');
+        return result.getData();
+    }
+    async deleteConfig(alertConfigId) {
+        await this.requestObject('/pulse/price-alert-configs/' + alertConfigId, null, (raw) => raw, 'DELETE');
+    }
+    async getEvents(alertConfigId, pagination = null) {
+        const queryString = new QueryString('/pulse/price-alert-configs/' + alertConfigId + '/events');
+        queryString.addPagination(pagination);
+        return await this.requestCollection(queryString, PriceAlertEvent.parse);
+    }
+    /**
+     * Record that someone has dealt with an event; it stays in the list. The API stamps who and
+     * when from the session, so the request carries no body.
+     */
+    async acknowledgeEvent(alertEventId) {
+        const result = await this.requestObject('/pulse/price-alert-events/' + alertEventId, {}, PriceAlertEvent.parse, 'PATCH');
+        return result.getData();
+    }
+}

package/dist/Pulse/Service/PricingEndpoint.d.ts

@@ -0,0 +1,40 @@
+import { CatalogId } from '../../Catalog/Model/CatalogId.js';
+import { CursorPagination } from '../../Model/Pagination/CursorPagination.js';
+import { CollectionResult } from '../../Model/Result/CollectionResult.js';
+import { Endpoint } from '../../Service/Endpoint.js';
+import { PriceSuggestion, PriceSuggestionStatus } from '../Model/PriceSuggestion.js';
+import { PricingRule } from '../Model/PricingRule.js';
+/** Fields accepted when writing a rule; camelCase keys are snake_cased by the base Endpoint. */
+export type PricingRuleData = {
+    name: string;
+    description?: string | null;
+    productGroup?: string | null;
+    conditions?: Record<string, unknown>;
+    actionType: string;
+    actionParams?: Record<string, unknown>;
+    floorMargin?: number | null;
+    floorPrice?: number | null;
+    ceilingPrice?: number | null;
+    ignoreIfNoCostPrice?: boolean;
+    priority?: number;
+    isActive?: boolean;
+};
+/**
+ * Repricing — the rules that propose prices (`/pulse/pricing-rules`) and the suggestions they
+ * produce (`/pulse/price-suggestions`).
+ */
+export declare class PricingEndpoint extends Endpoint {
+    getRules(catalogId: CatalogId | string, pagination?: CursorPagination | null): Promise<CollectionResult<PricingRule>>;
+    getRule(pricingRuleId: string): Promise<PricingRule | null>;
+    createRule(catalogId: CatalogId | string, data: PricingRuleData): Promise<PricingRule | null>;
+    updateRule(pricingRuleId: string, data: Partial<PricingRuleData>): Promise<PricingRule | null>;
+    deleteRule(pricingRuleId: string): Promise<void>;
+    /** Price suggestions of a catalog, optionally only those in one status. */
+    getSuggestions(catalogId: CatalogId | string, pagination?: CursorPagination | null, status?: string | null): Promise<CollectionResult<PriceSuggestion>>;
+    getSuggestion(priceSuggestionId: string): Promise<PriceSuggestion | null>;
+    /**
+     * Approve or reject a suggestion. Approving marks it for pushing back to the shop; the write
+     * itself is done by a flow, which sets `appliedAt`.
+     */
+    reviewSuggestion(priceSuggestionId: string, status: Exclude<PriceSuggestionStatus, 'pending'>): Promise<PriceSuggestion | null>;
+}

package/dist/Pulse/Service/PricingEndpoint.js

@@ -0,0 +1,51 @@
+import { QueryString } from '../../Http/Data/QueryString.js';
+import { Endpoint } from '../../Service/Endpoint.js';
+import { PriceSuggestion } from '../Model/PriceSuggestion.js';
+import { PricingRule } from '../Model/PricingRule.js';
+/**
+ * Repricing — the rules that propose prices (`/pulse/pricing-rules`) and the suggestions they
+ * produce (`/pulse/price-suggestions`).
+ */
+export class PricingEndpoint extends Endpoint {
+    async getRules(catalogId, pagination = null) {
+        const queryString = new QueryString('/pulse/catalogs/' + catalogId.toString() + '/pricing-rules');
+        queryString.addPagination(pagination);
+        return await this.requestCollection(queryString, PricingRule.parse);
+    }
+    async getRule(pricingRuleId) {
+        const result = await this.requestObject('/pulse/pricing-rules/' + pricingRuleId, null, PricingRule.parse, 'GET');
+        return result.getData();
+    }
+    async createRule(catalogId, data) {
+        const result = await this.requestObject('/pulse/catalogs/' + catalogId.toString() + '/pricing-rules', data, PricingRule.parse, 'POST');
+        return result.getData();
+    }
+    async updateRule(pricingRuleId, data) {
+        const result = await this.requestObject('/pulse/pricing-rules/' + pricingRuleId, data, PricingRule.parse, 'PATCH');
+        return result.getData();
+    }
+    async deleteRule(pricingRuleId) {
+        await this.requestObject('/pulse/pricing-rules/' + pricingRuleId, null, (raw) => raw, 'DELETE');
+    }
+    /** Price suggestions of a catalog, optionally only those in one status. */
+    async getSuggestions(catalogId, pagination = null, status = null) {
+        const queryString = new QueryString('/pulse/catalogs/' + catalogId.toString() + '/price-suggestions');
+        if (status !== null) {
+            queryString.set('status', status);
+        }
+        queryString.addPagination(pagination);
+        return await this.requestCollection(queryString, PriceSuggestion.parse);
+    }
+    async getSuggestion(priceSuggestionId) {
+        const result = await this.requestObject('/pulse/price-suggestions/' + priceSuggestionId, null, PriceSuggestion.parse, 'GET');
+        return result.getData();
+    }
+    /**
+     * Approve or reject a suggestion. Approving marks it for pushing back to the shop; the write
+     * itself is done by a flow, which sets `appliedAt`.
+     */
+    async reviewSuggestion(priceSuggestionId, status) {
+        const result = await this.requestObject('/pulse/price-suggestions/' + priceSuggestionId, { status }, PriceSuggestion.parse, 'PATCH');
+        return result.getData();
+    }
+}

package/dist/Pulse/Service/ProductGroupEndpoint.d.ts

@@ -0,0 +1,18 @@
+import { CatalogId } from '../../Catalog/Model/CatalogId.js';
+import { CursorPagination } from '../../Model/Pagination/CursorPagination.js';
+import { CollectionResult } from '../../Model/Result/CollectionResult.js';
+import { Endpoint } from '../../Service/Endpoint.js';
+import { ProductGroup, ProductGroupType } from '../Model/ProductGroup.js';
+/** Fields accepted when writing a group; camelCase keys are snake_cased by the base Endpoint. */
+export type ProductGroupData = {
+    name: string;
+    description?: string | null;
+    groupType?: ProductGroupType;
+    criteria?: Record<string, unknown>;
+};
+/** Product groups — `/pulse/catalogs/:catalogId/product-groups`. */
+export declare class ProductGroupEndpoint extends Endpoint {
+    getByCatalog(catalogId: CatalogId | string, pagination?: CursorPagination | null): Promise<CollectionResult<ProductGroup>>;
+    getById(productGroupId: string): Promise<ProductGroup | null>;
+    create(catalogId: CatalogId | string, data: ProductGroupData): Promise<ProductGroup | null>;
+}

package/dist/Pulse/Service/ProductGroupEndpoint.js

@@ -0,0 +1,19 @@
+import { QueryString } from '../../Http/Data/QueryString.js';
+import { Endpoint } from '../../Service/Endpoint.js';
+import { ProductGroup } from '../Model/ProductGroup.js';
+/** Product groups — `/pulse/catalogs/:catalogId/product-groups`. */
+export class ProductGroupEndpoint extends Endpoint {
+    async getByCatalog(catalogId, pagination = null) {
+        const queryString = new QueryString('/pulse/catalogs/' + catalogId.toString() + '/product-groups');
+        queryString.addPagination(pagination);
+        return await this.requestCollection(queryString, ProductGroup.parse);
+    }
+    async getById(productGroupId) {
+        const result = await this.requestObject('/pulse/product-groups/' + productGroupId, null, ProductGroup.parse, 'GET');
+        return result.getData();
+    }
+    async create(catalogId, data) {
+        const result = await this.requestObject('/pulse/catalogs/' + catalogId.toString() + '/product-groups', data, ProductGroup.parse, 'POST');
+        return result.getData();
+    }
+}

package/dist/Pulse/Service/ProductMatchEndpoint.d.ts

@@ -0,0 +1,47 @@
+import { CatalogId } from '../../Catalog/Model/CatalogId.js';
+import { CursorPagination } from '../../Model/Pagination/CursorPagination.js';
+import { CollectionResult } from '../../Model/Result/CollectionResult.js';
+import { Endpoint } from '../../Service/Endpoint.js';
+import { ProductMatch } from '../Model/ProductMatch.js';
+import { ReviewMatch } from '../Model/ReviewMatch.js';
+/** Narrows the review queue. Omitting `statuses` returns the pending ones. */
+export type ReviewMatchFilters = {
+    statuses?: string[];
+    competitor?: string;
+    gtin?: string;
+    search?: string;
+};
+export type MatchHistoryInterval = 'day' | 'week' | 'month';
+/** Matches discovered and reviewed within one bucket of the history. */
+export type MatchHistoryBucket = {
+    date: Date;
+    discovered: number;
+    manualAccepted: number;
+    manualDeclined: number;
+};
+/** A match-history series plus where the queue stands right now. */
+export type MatchHistory = {
+    interval: MatchHistoryInterval;
+    buckets: MatchHistoryBucket[];
+    snapshot: {
+        pending: number;
+        accepted: number;
+        declined: number;
+    };
+};
+/**
+ * Product matches — reviewing the queue, accepting or declining a match, and the history of how
+ * the queue has moved.
+ */
+export declare class ProductMatchEndpoint extends Endpoint {
+    /** The review queue of a catalog; pending matches unless `statuses` says otherwise. */
+    getForReview(catalogId: CatalogId | string, pagination?: CursorPagination | null, filters?: ReviewMatchFilters): Promise<CollectionResult<ReviewMatch>>;
+    /** The match record, or null. */
+    getById(matchId: string): Promise<ProductMatch | null>;
+    /** Confirm a match. `note` records why, for the reviewer's own audit trail. */
+    accept(matchId: string, note?: string | null): Promise<void>;
+    /** Reject a match, so it stops counting towards the competitor's price index. */
+    decline(matchId: string, note?: string | null): Promise<void>;
+    /** How many matches were discovered and reviewed over time, optionally for one competitor. */
+    getHistory(catalogId: CatalogId | string, competitor?: string | null, interval?: MatchHistoryInterval): Promise<MatchHistory>;
+}

package/dist/Pulse/Service/ProductMatchEndpoint.js

@@ -0,0 +1,66 @@
+import { QueryString } from '../../Http/Data/QueryString.js';
+import { Endpoint } from '../../Service/Endpoint.js';
+import { ProductMatch } from '../Model/ProductMatch.js';
+import { ReviewMatch } from '../Model/ReviewMatch.js';
+/**
+ * Product matches — reviewing the queue, accepting or declining a match, and the history of how
+ * the queue has moved.
+ */
+export class ProductMatchEndpoint extends Endpoint {
+    /** The review queue of a catalog; pending matches unless `statuses` says otherwise. */
+    async getForReview(catalogId, pagination = null, filters = {}) {
+        const queryString = new QueryString('/pulse/catalogs/' + catalogId.toString() + '/matches');
+        queryString.set('status', (filters.statuses ?? ['pending']).join(','));
+        if (filters.competitor) {
+            queryString.set('competitor', filters.competitor);
+        }
+        if (filters.gtin) {
+            queryString.set('gtin', filters.gtin);
+        }
+        if (filters.search) {
+            queryString.set('search', filters.search);
+        }
+        queryString.addPagination(pagination);
+        return await this.requestCollection(queryString, ReviewMatch.parse);
+    }
+    /** The match record, or null. */
+    async getById(matchId) {
+        const result = await this.requestObject('/pulse/matches/' + matchId, null, ProductMatch.parse, 'GET');
+        return result.getData();
+    }
+    /** Confirm a match. `note` records why, for the reviewer's own audit trail. */
+    async accept(matchId, note = null) {
+        await this.requestObject('/pulse/matches/' + matchId + '/accept', note === null ? {} : { note }, (raw) => raw, 'POST');
+    }
+    /** Reject a match, so it stops counting towards the competitor's price index. */
+    async decline(matchId, note = null) {
+        await this.requestObject('/pulse/matches/' + matchId + '/decline', note === null ? {} : { note }, (raw) => raw, 'POST');
+    }
+    /** How many matches were discovered and reviewed over time, optionally for one competitor. */
+    async getHistory(catalogId, competitor = null, interval = 'day') {
+        const queryString = new QueryString('/pulse/catalogs/' + catalogId.toString() + '/matches/history');
+        queryString.set('interval', interval);
+        if (competitor !== null) {
+            queryString.set('competitor', competitor);
+        }
+        const result = await this.requestObject(queryString, null, (raw) => {
+            const buckets = raw.buckets ?? [];
+            const snapshot = raw.snapshot ?? {};
+            return {
+                interval: raw.interval ?? interval,
+                buckets: buckets.map((bucket) => ({
+                    date: new Date(bucket.date),
+                    discovered: bucket.discovered ?? 0,
+                    manualAccepted: bucket.manual_accepted ?? 0,
+                    manualDeclined: bucket.manual_declined ?? 0,
+                })),
+                snapshot: {
+                    pending: snapshot.pending ?? 0,
+                    accepted: snapshot.accepted ?? 0,
+                    declined: snapshot.declined ?? 0,
+                },
+            };
+        }, 'GET');
+        return result.getData() ?? { interval, buckets: [], snapshot: { pending: 0, accepted: 0, declined: 0 } };
+    }
+}

package/dist/Pulse/Service/ProductMatchJobEndpoint.d.ts

@@ -0,0 +1,19 @@
+import { CatalogId } from '../../Catalog/Model/CatalogId.js';
+import { CursorPagination } from '../../Model/Pagination/CursorPagination.js';
+import { ProductMatchJob } from '../Model/ProductMatchJob.js';
+import { CollectionResult } from '../../Model/Result/CollectionResult.js';
+import { Endpoint } from '../../Service/Endpoint.js';
+/**
+ * Market Pulse product match jobs — `/pulse/match-jobs`. All three routes return the same shape,
+ * so they share {@link ProductMatchJob}.
+ */
+export declare class ProductMatchJobEndpoint extends Endpoint {
+    /** Every match job of a catalog, newest first. */
+    getByCatalog(catalogId: CatalogId | string, pagination?: CursorPagination | null): Promise<CollectionResult<ProductMatchJob>>;
+    /** The match jobs of one of the catalog's competitors. */
+    getByVendor(catalogId: CatalogId | string, vendorId: string, pagination?: CursorPagination | null): Promise<CollectionResult<ProductMatchJob>>;
+    /** Queue a matching run of the catalog against one competitor. */
+    requestMatching(catalogId: CatalogId | string, vendorId: string): Promise<void>;
+    /** The match job with this id, or null. */
+    getById(productMatchJobId: string): Promise<ProductMatchJob | null>;
+}

package/dist/Pulse/Service/ProductMatchJobEndpoint.js

@@ -0,0 +1,30 @@
+import { QueryString } from '../../Http/Data/QueryString.js';
+import { ProductMatchJob } from '../Model/ProductMatchJob.js';
+import { Endpoint } from '../../Service/Endpoint.js';
+/**
+ * Market Pulse product match jobs — `/pulse/match-jobs`. All three routes return the same shape,
+ * so they share {@link ProductMatchJob}.
+ */
+export class ProductMatchJobEndpoint extends Endpoint {
+    /** Every match job of a catalog, newest first. */
+    async getByCatalog(catalogId, pagination = null) {
+        const queryString = new QueryString('/pulse/catalogs/' + catalogId.toString() + '/match-jobs');
+        queryString.addPagination(pagination);
+        return await this.requestCollection(queryString, ProductMatchJob.parse);
+    }
+    /** The match jobs of one of the catalog's competitors. */
+    async getByVendor(catalogId, vendorId, pagination = null) {
+        const queryString = new QueryString('/pulse/catalogs/' + catalogId.toString() + '/vendors/' + vendorId + '/match-jobs');
+        queryString.addPagination(pagination);
+        return await this.requestCollection(queryString, ProductMatchJob.parse);
+    }
+    /** Queue a matching run of the catalog against one competitor. */
+    async requestMatching(catalogId, vendorId) {
+        await this.requestObject('/pulse/catalogs/' + catalogId.toString() + '/vendors/' + vendorId + '/match', {}, (raw) => raw, 'POST');
+    }
+    /** The match job with this id, or null. */
+    async getById(productMatchJobId) {
+        const result = await this.requestObject('/pulse/match-jobs/' + productMatchJobId, null, ProductMatchJob.parse, 'GET');
+        return result.getData();
+    }
+}

package/dist/Pulse/Service/PulseCatalogProductEndpoint.d.ts

@@ -0,0 +1,40 @@
+import { CatalogId } from '../../Catalog/Model/CatalogId.js';
+import { FilterNode } from '../../Model/Filter/FilterNode.js';
+import { CursorPagination } from '../../Model/Pagination/CursorPagination.js';
+import { CollectionResult } from '../../Model/Result/CollectionResult.js';
+import { Endpoint } from '../../Service/Endpoint.js';
+import { CatalogProductWithMatches } from '../Model/CatalogProductWithMatches.js';
+/** Simple narrowing of the product list; `tags` filters on materialised tag values. */
+export type PulseCatalogProductFilters = {
+    brand?: string;
+    category?: string;
+    search?: string;
+    productGroup?: string;
+    tags?: Record<string, string>;
+};
+/** The values the product list can currently be filtered on. */
+export type PulseCatalogProductFilterOptions = {
+    brands: string[];
+    categories: string[];
+    productGroups: {
+        id: string;
+        name: string;
+    }[];
+    tags: Record<string, string[]>;
+};
+/**
+ * A catalog's own products as Market Pulse sees them — with the competitor products matched to
+ * each. `/pulse/catalogs/:catalogId/products`.
+ */
+export declare class PulseCatalogProductEndpoint extends Endpoint {
+    /**
+     * The catalog's products, each with its matches expanded.
+     *
+     * `filters` covers the common narrowing; `filter` takes a structured {@link FilterNode} for
+     * anything the simple filters cannot express.
+     */
+    getProducts(catalogId: CatalogId | string, pagination?: CursorPagination | null, filters?: PulseCatalogProductFilters, filter?: FilterNode | null): Promise<CollectionResult<CatalogProductWithMatches>>;
+    getFilterOptions(catalogId: CatalogId | string): Promise<PulseCatalogProductFilterOptions>;
+    /** Recalculate the catalog's cached statistics (price index, match counts, segments). */
+    recomputeStatistics(catalogId: CatalogId | string): Promise<void>;
+}

package/dist/Pulse/Service/PulseCatalogProductEndpoint.js

@@ -0,0 +1,54 @@
+import { QueryString } from '../../Http/Data/QueryString.js';
+import { Endpoint } from '../../Service/Endpoint.js';
+import { CatalogProductWithMatches } from '../Model/CatalogProductWithMatches.js';
+/**
+ * A catalog's own products as Market Pulse sees them — with the competitor products matched to
+ * each. `/pulse/catalogs/:catalogId/products`.
+ */
+export class PulseCatalogProductEndpoint extends Endpoint {
+    /**
+     * The catalog's products, each with its matches expanded.
+     *
+     * `filters` covers the common narrowing; `filter` takes a structured {@link FilterNode} for
+     * anything the simple filters cannot express.
+     */
+    async getProducts(catalogId, pagination = null, filters = {}, filter = null) {
+        const queryString = new QueryString('/pulse/catalogs/' + catalogId.toString() + '/products');
+        queryString.set('expand', ['matches.vendor']);
+        if (filters.brand) {
+            queryString.set('brand', filters.brand);
+        }
+        if (filters.category) {
+            queryString.set('category', filters.category);
+        }
+        if (filters.search) {
+            queryString.set('search', filters.search);
+        }
+        if (filters.productGroup) {
+            queryString.set('product_group', filters.productGroup);
+        }
+        if (filters.tags) {
+            for (const [key, value] of Object.entries(filters.tags)) {
+                queryString.set('tag[' + key + ']', value);
+            }
+        }
+        if (filter !== null) {
+            queryString.set('filter', JSON.stringify(filter));
+        }
+        queryString.addPagination(pagination);
+        return await this.requestCollection(queryString, CatalogProductWithMatches.parse);
+    }
+    async getFilterOptions(catalogId) {
+        const result = await this.requestObject('/pulse/catalogs/' + catalogId.toString() + '/filter-options', null, (raw) => ({
+            brands: raw.brands ?? [],
+            categories: raw.categories ?? [],
+            productGroups: raw.product_groups ?? [],
+            tags: raw.tags ?? {},
+        }), 'GET');
+        return result.getData() ?? { brands: [], categories: [], productGroups: [], tags: {} };
+    }
+    /** Recalculate the catalog's cached statistics (price index, match counts, segments). */
+    async recomputeStatistics(catalogId) {
+        await this.requestObject('/pulse/catalogs/' + catalogId.toString() + '/recompute-stats', {}, (raw) => raw, 'POST');
+    }
+}

package/dist/Pulse/Service/PulseStatisticsEndpoint.d.ts

@@ -0,0 +1,44 @@
+import { CatalogId } from '../../Catalog/Model/CatalogId.js';
+import { CollectionResult } from '../../Model/Result/CollectionResult.js';
+import { Endpoint } from '../../Service/Endpoint.js';
+import { PriceIndexSnapshotEntry } from '../Model/PriceIndexSnapshotEntry.js';
+import { TopCompetitor } from '../Model/TopCompetitor.js';
+/** Which axis the products are bucketed on. */
+export type ProductSegmentType = 'price' | 'profit';
+/** How many products fall in a segment now versus the previous period. */
+export type ProductsSegment = {
+    code: string;
+    current: number;
+    previous: number;
+};
+/** One headline figure of the catalog, with its previous-period value to compare against. */
+export type MarketSummaryEntry = {
+    id: string;
+    title: string;
+    currentAmount: number;
+    previousAmount: number;
+};
+/**
+ * Aggregated Market Pulse figures for a catalog — `/pulse/catalogs/:catalogId/statistics/*`.
+ * These are precomputed server-side; `CatalogProductEndpoint.recomputeStatistics` refreshes them.
+ */
+export declare class PulseStatisticsEndpoint extends Endpoint {
+    /** Headline figures (products tracked, matches, competitors …) against the previous period. */
+    getAccountSummary(catalogId: CatalogId | string): Promise<CollectionResult<MarketSummaryEntry>>;
+    /** Distribution of the catalog's products across price or profit segments. */
+    getProductSegments(catalogId: CatalogId | string, type?: ProductSegmentType | null): Promise<CollectionResult<ProductsSegment>>;
+    /**
+     * The competitors with the most matches against this catalog. `period` is the number of days
+     * the comparison against the previous period spans.
+     */
+    getTopCompetitors(catalogId: CatalogId | string, limit?: number | null, period?: number | null): Promise<CollectionResult<TopCompetitor>>;
+    /**
+     * Price index per competitor over time, for charting. Pass the competitors to include, and
+     * optionally a product group to scope to and a date range (`YYYY-MM-DD`).
+     */
+    getPriceIndexHistory(catalogId: CatalogId | string, competitorIds?: string[], options?: {
+        group?: string;
+        from?: string;
+        to?: string;
+    }): Promise<CollectionResult<PriceIndexSnapshotEntry>>;
+}

package/dist/Pulse/Service/PulseStatisticsEndpoint.js

@@ -0,0 +1,65 @@
+import { QueryString } from '../../Http/Data/QueryString.js';
+import { Endpoint } from '../../Service/Endpoint.js';
+import { PriceIndexSnapshotEntry } from '../Model/PriceIndexSnapshotEntry.js';
+import { TopCompetitor } from '../Model/TopCompetitor.js';
+/**
+ * Aggregated Market Pulse figures for a catalog — `/pulse/catalogs/:catalogId/statistics/*`.
+ * These are precomputed server-side; `CatalogProductEndpoint.recomputeStatistics` refreshes them.
+ */
+export class PulseStatisticsEndpoint extends Endpoint {
+    /** Headline figures (products tracked, matches, competitors …) against the previous period. */
+    async getAccountSummary(catalogId) {
+        return await this.requestCollection('/pulse/catalogs/' + catalogId.toString() + '/statistics/account-summary', (raw) => ({
+            id: raw.id,
+            title: raw.title,
+            currentAmount: raw.current_amount ?? 0,
+            previousAmount: raw.previous_amount ?? 0,
+        }));
+    }
+    /** Distribution of the catalog's products across price or profit segments. */
+    async getProductSegments(catalogId, type = null) {
+        const queryString = new QueryString('/pulse/catalogs/' + catalogId.toString() + '/statistics/product-segments');
+        if (type !== null) {
+            queryString.set('type', type);
+        }
+        return await this.requestCollection(queryString, (raw) => ({
+            code: raw.code,
+            current: raw.current ?? 0,
+            previous: raw.previous ?? 0,
+        }));
+    }
+    /**
+     * The competitors with the most matches against this catalog. `period` is the number of days
+     * the comparison against the previous period spans.
+     */
+    async getTopCompetitors(catalogId, limit = null, period = null) {
+        const queryString = new QueryString('/pulse/catalogs/' + catalogId.toString() + '/statistics/top-competitors');
+        if (limit !== null) {
+            queryString.set('limit', limit);
+        }
+        if (period !== null) {
+            queryString.set('period', period);
+        }
+        return await this.requestCollection(queryString, TopCompetitor.parse);
+    }
+    /**
+     * Price index per competitor over time, for charting. Pass the competitors to include, and
+     * optionally a product group to scope to and a date range (`YYYY-MM-DD`).
+     */
+    async getPriceIndexHistory(catalogId, competitorIds = [], options = {}) {
+        const queryString = new QueryString('/pulse/catalogs/' + catalogId.toString() + '/statistics/price-index-history');
+        if (competitorIds.length > 0) {
+            queryString.set('competitor', competitorIds.join(','));
+        }
+        if (options.group) {
+            queryString.set('group', options.group);
+        }
+        if (options.from) {
+            queryString.set('from', options.from);
+        }
+        if (options.to) {
+            queryString.set('to', options.to);
+        }
+        return await this.requestCollection(queryString, PriceIndexSnapshotEntry.parse);
+    }
+}