@attlaz/client 1.88.0 → 1.89.0

package/dist/Model/Search/SearchResult.js

@@ -3,8 +3,8 @@ import { AdapterConnection } from '../Adapter/AdapterConnection.js';
 import { CodeSource } from '../Deployment/CodeSource.js';
 import { CodeSourceAccount } from '../Deployment/CodeSourceAccount.js';
 import { EntityType } from '../EntityType.js';
-import { Flow } from '../Flow/Flow.js';
-import { FlowRun } from '../Flow/FlowRun.js';
+import { Flow } from '../../Flow/Model/Flow.js';
+import { FlowRun } from '../../Flow/Model/FlowRun.js';
 import { Channel } from '../Messaging/Channel/Channel.js';
 import { Subscriber } from '../Messaging/Subscriber.js';
 import { CodeDeploy } from '../Project/CodeDeploy.js';

package/dist/Pulse/Model/CatalogProductWithMatches.d.ts

@@ -0,0 +1,31 @@
+import { ApiRecord } from '../../Model/ApiRecord.js';
+import { MatchedVendorProduct } from './MatchedVendorProduct.js';
+/** What a pricing strategy proposes for a product, and which rule proposed it. */
+export type PriceProposal = {
+    price: number;
+    strategyName: string;
+    strategyDetails: string;
+};
+/**
+ * One of the catalog's products with the competitor products matched to it — the
+ * `/pulse/catalogs/:catalogId/products` resource.
+ *
+ * `costPrice` is only present when the catalog carries cost data; margin and profit are left to
+ * the caller, since what counts as margin differs per client.
+ */
+export declare class CatalogProductWithMatches {
+    id: string;
+    name: string;
+    image: string | null;
+    gtin: string | null;
+    brand: string | null;
+    url: string | null;
+    price: number;
+    costPrice: number | null;
+    priceProposal: PriceProposal | null;
+    matches: MatchedVendorProduct[];
+    constructor(id: string);
+    /** Mean price of the matched competitor products; null when nothing matched. */
+    get matchesAveragePrice(): number | null;
+    static parse(raw: ApiRecord): CatalogProductWithMatches;
+}

package/dist/Pulse/Model/CatalogProductWithMatches.js

@@ -0,0 +1,50 @@
+import { MatchedVendorProduct } from './MatchedVendorProduct.js';
+/**
+ * One of the catalog's products with the competitor products matched to it — the
+ * `/pulse/catalogs/:catalogId/products` resource.
+ *
+ * `costPrice` is only present when the catalog carries cost data; margin and profit are left to
+ * the caller, since what counts as margin differs per client.
+ */
+export class CatalogProductWithMatches {
+    id;
+    name = '';
+    image = null;
+    gtin = null;
+    brand = null;
+    url = null;
+    price = 0;
+    costPrice = null;
+    priceProposal = null;
+    matches = [];
+    constructor(id) {
+        this.id = id;
+    }
+    /** Mean price of the matched competitor products; null when nothing matched. */
+    get matchesAveragePrice() {
+        if (this.matches.length === 0) {
+            return null;
+        }
+        const total = this.matches.reduce((sum, match) => sum + match.price, 0);
+        return total / this.matches.length;
+    }
+    static parse(raw) {
+        const product = new CatalogProductWithMatches(raw.id);
+        product.name = raw.name ?? '';
+        product.image = raw.image ?? null;
+        product.gtin = raw.gtin ?? null;
+        product.brand = raw.brand ?? null;
+        product.url = raw.url ?? null;
+        product.price = parseFloat(raw.price) || 0;
+        product.costPrice = raw.cost_price ?? null;
+        const proposal = raw.price_proposal ?? null;
+        product.priceProposal = proposal === null ? null : {
+            price: proposal.price,
+            strategyName: proposal.strategy_name,
+            strategyDetails: proposal.strategy_details,
+        };
+        const matches = raw.matches ?? [];
+        product.matches = matches.map((match) => MatchedVendorProduct.parse(match));
+        return product;
+    }
+}

package/dist/Pulse/Model/CompetingVendorProduct.d.ts

@@ -0,0 +1,15 @@
+import { ApiRecord } from '../../Model/ApiRecord.js';
+import { VendorProduct } from './VendorProduct.js';
+/**
+ * A competitor's product read through the catalog's competitor —
+ * `/pulse/competing-vendors/:competitorId/products`.
+ *
+ * The same product as {@link VendorProduct}; the competitor is what the catalog knows the vendor
+ * as, so it exists only on this view. A vendor can be a competitor in several catalogs, which is
+ * why `competitorId` is not a property of the product itself.
+ */
+export declare class CompetingVendorProduct extends VendorProduct {
+    competitorId: string;
+    constructor(vendorId: string, identifier: string, competitorId: string);
+    static parse(raw: ApiRecord): CompetingVendorProduct;
+}

package/dist/Pulse/Model/CompetingVendorProduct.js

@@ -0,0 +1,21 @@
+import { VendorProduct } from './VendorProduct.js';
+/**
+ * A competitor's product read through the catalog's competitor —
+ * `/pulse/competing-vendors/:competitorId/products`.
+ *
+ * The same product as {@link VendorProduct}; the competitor is what the catalog knows the vendor
+ * as, so it exists only on this view. A vendor can be a competitor in several catalogs, which is
+ * why `competitorId` is not a property of the product itself.
+ */
+export class CompetingVendorProduct extends VendorProduct {
+    competitorId;
+    constructor(vendorId, identifier, competitorId) {
+        super(vendorId, identifier);
+        this.competitorId = competitorId;
+    }
+    static parse(raw) {
+        const product = new CompetingVendorProduct(raw.vendor, raw.identifier, raw.competitor);
+        product.fill(raw);
+        return product;
+    }
+}

package/dist/Pulse/Model/Competitor.d.ts

@@ -0,0 +1,27 @@
+import { ApiRecord } from '../../Model/ApiRecord.js';
+/**
+ * A vendor as one catalog watches it — the `/pulse/catalogs/:catalogId/competing-vendors` resource
+ * (a `Competitor` server-side). The same vendor can be a competitor in several catalogs, which is
+ * why the counts and timestamps below belong here and not on {@link Vendor}.
+ *
+ * `priceIndex` is this competitor's prices relative to the catalog's own, over the matched
+ * products: 100 means level, below 100 means the competitor is cheaper.
+ */
+export declare class Competitor {
+    id: string;
+    vendorId: string;
+    name: string;
+    domain: string;
+    icon: string | null;
+    type: string | null;
+    /** Which index (embedding set) the competitor's products are held in. */
+    index: string;
+    matchCount: number;
+    productCount: number;
+    priceIndex: number;
+    lastScrapedAt: Date | null;
+    lastIndexedAt: Date | null;
+    lastMatchedAt: Date | null;
+    constructor(id: string, vendorId: string, name: string);
+    static parse(raw: ApiRecord): Competitor;
+}

package/dist/Pulse/Model/Competitor.js

@@ -0,0 +1,43 @@
+/**
+ * A vendor as one catalog watches it — the `/pulse/catalogs/:catalogId/competing-vendors` resource
+ * (a `Competitor` server-side). The same vendor can be a competitor in several catalogs, which is
+ * why the counts and timestamps below belong here and not on {@link Vendor}.
+ *
+ * `priceIndex` is this competitor's prices relative to the catalog's own, over the matched
+ * products: 100 means level, below 100 means the competitor is cheaper.
+ */
+export class Competitor {
+    id;
+    vendorId;
+    name;
+    domain = '';
+    icon = null;
+    type = null;
+    /** Which index (embedding set) the competitor's products are held in. */
+    index = '';
+    matchCount = 0;
+    productCount = 0;
+    priceIndex = 0;
+    lastScrapedAt = null;
+    lastIndexedAt = null;
+    lastMatchedAt = null;
+    constructor(id, vendorId, name) {
+        this.id = id;
+        this.vendorId = vendorId;
+        this.name = name;
+    }
+    static parse(raw) {
+        const competitor = new Competitor(raw.id, raw.vendor, raw.name ?? '');
+        competitor.domain = raw.domain ?? '';
+        competitor.icon = raw.icon ?? null;
+        competitor.type = raw.type ?? null;
+        competitor.index = raw.index ?? '';
+        competitor.matchCount = Number(raw.match_count ?? 0);
+        competitor.productCount = Number(raw.product_count ?? 0);
+        competitor.priceIndex = Number(raw.price_index ?? 0);
+        competitor.lastScrapedAt = raw.last_scraped_at ? new Date(raw.last_scraped_at) : null;
+        competitor.lastIndexedAt = raw.last_indexed_at ? new Date(raw.last_indexed_at) : null;
+        competitor.lastMatchedAt = raw.last_matched_at ? new Date(raw.last_matched_at) : null;
+        return competitor;
+    }
+}

package/dist/{Model/Pulse → Pulse/Model}/CrawlJob.d.ts

@@ -1,5 +1,5 @@
-import { ApiRecord } from '../ApiRecord.js';
-export type CrawlJobStatus = 'pending' | 'started' | 'cancelled' | 'finished';
+import { ApiRecord } from '../../Model/ApiRecord.js';
+export type CrawlJobStatus = 'pending' | 'started' | 'cancelled' | 'stopped' | 'finished';
 /**
  * A Market Pulse crawl job: one run of scraping a vendor. Its lifecycle (pending → started →
  * finished) drives the vendor's "last scraped" timestamp (`finishedAt`) and, on finish, triggers

package/dist/Pulse/Model/IndexJob.d.ts

@@ -0,0 +1,19 @@
+import { ApiRecord } from '../../Model/ApiRecord.js';
+export type IndexJobStatus = 'pending' | 'started' | 'cancelled' | 'stopped' | 'finished';
+/**
+ * One run of building the embeddings for a vendor's products — the `/pulse/…/index-jobs` resource.
+ * Matching a competitor requires its products to be indexed first, so an index job is the step
+ * between crawling and {@link ProductMatchJob}.
+ */
+export declare class IndexJob {
+    id: string;
+    vendorId: string;
+    status: IndexJobStatus;
+    productsTotal: number | null;
+    productsProcessed: number | null;
+    createdAt: Date | null;
+    startedAt: Date | null;
+    completedAt: Date | null;
+    constructor(id: string, vendorId: string);
+    static parse(raw: ApiRecord): IndexJob;
+}

package/dist/Pulse/Model/IndexJob.js

@@ -0,0 +1,29 @@
+/**
+ * One run of building the embeddings for a vendor's products — the `/pulse/…/index-jobs` resource.
+ * Matching a competitor requires its products to be indexed first, so an index job is the step
+ * between crawling and {@link ProductMatchJob}.
+ */
+export class IndexJob {
+    id;
+    vendorId;
+    status = 'pending';
+    productsTotal = null;
+    productsProcessed = null;
+    createdAt = null;
+    startedAt = null;
+    completedAt = null;
+    constructor(id, vendorId) {
+        this.id = id;
+        this.vendorId = vendorId;
+    }
+    static parse(raw) {
+        const job = new IndexJob(raw.id, raw.vendor);
+        job.status = raw.status ?? 'pending';
+        job.productsTotal = raw.products_total ?? null;
+        job.productsProcessed = raw.products_processed ?? null;
+        job.createdAt = raw.created_at ? new Date(raw.created_at) : null;
+        job.startedAt = raw.started_at ? new Date(raw.started_at) : null;
+        job.completedAt = raw.completed_at ? new Date(raw.completed_at) : null;
+        return job;
+    }
+}

package/dist/Pulse/Model/MatchedVendorProduct.d.ts

@@ -0,0 +1,29 @@
+import { ApiRecord } from '../../Model/ApiRecord.js';
+import { Vendor } from './Vendor.js';
+/**
+ * A competitor's product as it appears against one of your own — what
+ * `/pulse/catalogs/:catalogId/products?expand=matches.vendor` nests under each product.
+ *
+ * It carries the competitor product's own fields plus the linkage back to the match record
+ * ({@link ProductMatch}) and the job that produced it, so the UI can show the price side by side
+ * and still open the match.
+ */
+export declare class MatchedVendorProduct {
+    /** Id of the competitor's product. */
+    id: string;
+    /** Id of the match record joining it to your product; null for an unreviewed direct hit. */
+    matchId: string | null;
+    matchJobId: string | null;
+    vendor: Vendor | null;
+    name: string;
+    image: string | null;
+    brand: string | null;
+    gtin: string | null;
+    url: string | null;
+    price: number;
+    shippingCost: number;
+    inStock: boolean | null;
+    updatedAt: Date | null;
+    constructor(id: string);
+    static parse(raw: ApiRecord): MatchedVendorProduct;
+}

package/dist/Pulse/Model/MatchedVendorProduct.js

@@ -0,0 +1,48 @@
+import { Vendor } from './Vendor.js';
+/**
+ * A competitor's product as it appears against one of your own — what
+ * `/pulse/catalogs/:catalogId/products?expand=matches.vendor` nests under each product.
+ *
+ * It carries the competitor product's own fields plus the linkage back to the match record
+ * ({@link ProductMatch}) and the job that produced it, so the UI can show the price side by side
+ * and still open the match.
+ */
+export class MatchedVendorProduct {
+    /** Id of the competitor's product. */
+    id;
+    /** Id of the match record joining it to your product; null for an unreviewed direct hit. */
+    matchId = null;
+    matchJobId = null;
+    vendor = null;
+    name = '';
+    image = null;
+    brand = null;
+    gtin = null;
+    url = null;
+    price = 0;
+    shippingCost = 0;
+    inStock = null;
+    updatedAt = null;
+    constructor(id) {
+        this.id = id;
+    }
+    static parse(raw) {
+        const product = new MatchedVendorProduct(raw.id);
+        product.matchId = raw.match ?? null;
+        product.matchJobId = raw.match_job ?? null;
+        const vendor = raw.vendor;
+        if (vendor !== null && typeof vendor === 'object') {
+            product.vendor = Vendor.parse(vendor);
+        }
+        product.name = raw.name ?? '';
+        product.image = raw.image ?? null;
+        product.brand = raw.brand ?? null;
+        product.gtin = raw.gtin ?? null;
+        product.url = raw.url ?? null;
+        product.price = parseFloat(raw.price) || 0;
+        product.shippingCost = parseFloat(raw.shipping_cost) || 0;
+        product.inStock = typeof raw.in_stock === 'boolean' ? raw.in_stock : null;
+        product.updatedAt = raw.updated ? new Date(raw.updated) : null;
+        return product;
+    }
+}

package/dist/Pulse/Model/PriceAlertConfig.d.ts

@@ -0,0 +1,22 @@
+import { ApiRecord } from '../../Model/ApiRecord.js';
+/**
+ * A standing rule that watches a catalog's prices against its competitors and notifies a channel
+ * when it fires — the `/pulse/price-alert-configs` resource.
+ *
+ * `conditionType` names the check and `conditionParams` carries its thresholds, so a new kind of
+ * alert does not change this shape. `productGroup` narrows it to part of the catalog.
+ */
+export declare class PriceAlertConfig {
+    id: string;
+    catalogId: string;
+    name: string;
+    conditionType: string;
+    conditionParams: Record<string, unknown>;
+    productGroupId: string | null;
+    /** The messaging channel the alert is delivered to. */
+    channelId: string;
+    isActive: boolean;
+    createdAt: Date | null;
+    constructor(id: string, catalogId: string, name: string);
+    static parse(raw: ApiRecord): PriceAlertConfig;
+}

package/dist/Pulse/Model/PriceAlertConfig.js

@@ -0,0 +1,34 @@
+/**
+ * A standing rule that watches a catalog's prices against its competitors and notifies a channel
+ * when it fires — the `/pulse/price-alert-configs` resource.
+ *
+ * `conditionType` names the check and `conditionParams` carries its thresholds, so a new kind of
+ * alert does not change this shape. `productGroup` narrows it to part of the catalog.
+ */
+export class PriceAlertConfig {
+    id;
+    catalogId;
+    name;
+    conditionType = '';
+    conditionParams = {};
+    productGroupId = null;
+    /** The messaging channel the alert is delivered to. */
+    channelId = '';
+    isActive = true;
+    createdAt = null;
+    constructor(id, catalogId, name) {
+        this.id = id;
+        this.catalogId = catalogId;
+        this.name = name;
+    }
+    static parse(raw) {
+        const config = new PriceAlertConfig(raw.id, raw.catalog, raw.name ?? '');
+        config.conditionType = raw.condition_type ?? '';
+        config.conditionParams = raw.condition_params ?? {};
+        config.productGroupId = raw.product_group ?? null;
+        config.channelId = raw.channel_id ?? '';
+        config.isActive = raw.is_active !== false;
+        config.createdAt = raw.created_at ? new Date(raw.created_at) : null;
+        return config;
+    }
+}

package/dist/Pulse/Model/PriceAlertEvent.d.ts

@@ -0,0 +1,20 @@
+import { ApiRecord } from '../../Model/ApiRecord.js';
+/**
+ * One firing of a {@link PriceAlertConfig} — the `/pulse/price-alert-configs/:id/events` resource.
+ *
+ * `data` holds the values that tripped the condition, so the event stays readable even after the
+ * prices move on. Acknowledging one records who dealt with it; it is not deleted.
+ */
+export declare class PriceAlertEvent {
+    id: string;
+    alertConfigId: string;
+    catalogProductId: string | null;
+    vendorProductId: string | null;
+    triggeredAt: Date | null;
+    data: Record<string, unknown>;
+    acknowledgedAt: Date | null;
+    acknowledgedBy: string | null;
+    constructor(id: string, alertConfigId: string);
+    get isAcknowledged(): boolean;
+    static parse(raw: ApiRecord): PriceAlertEvent;
+}

package/dist/Pulse/Model/PriceAlertEvent.js

@@ -0,0 +1,33 @@
+/**
+ * One firing of a {@link PriceAlertConfig} — the `/pulse/price-alert-configs/:id/events` resource.
+ *
+ * `data` holds the values that tripped the condition, so the event stays readable even after the
+ * prices move on. Acknowledging one records who dealt with it; it is not deleted.
+ */
+export class PriceAlertEvent {
+    id;
+    alertConfigId;
+    catalogProductId = null;
+    vendorProductId = null;
+    triggeredAt = null;
+    data = {};
+    acknowledgedAt = null;
+    acknowledgedBy = null;
+    constructor(id, alertConfigId) {
+        this.id = id;
+        this.alertConfigId = alertConfigId;
+    }
+    get isAcknowledged() {
+        return this.acknowledgedAt !== null;
+    }
+    static parse(raw) {
+        const event = new PriceAlertEvent(raw.id, raw.alert_config);
+        event.catalogProductId = raw.catalog_product ?? null;
+        event.vendorProductId = raw.vendor_product ?? null;
+        event.triggeredAt = raw.triggered_at ? new Date(raw.triggered_at) : null;
+        event.data = raw.data ?? {};
+        event.acknowledgedAt = raw.acknowledged_at ? new Date(raw.acknowledged_at) : null;
+        event.acknowledgedBy = raw.acknowledged_by ?? null;
+        return event;
+    }
+}

package/dist/Pulse/Model/PriceIndexSnapshotEntry.d.ts

@@ -0,0 +1,16 @@
+import { ApiRecord } from '../../Model/ApiRecord.js';
+/**
+ * One competitor's price index on one day — the
+ * `/pulse/catalogs/:catalogId/statistics/price-index-history` resource.
+ *
+ * `date` stays the API's `YYYY-MM-DD` string rather than a Date: these are calendar buckets, and
+ * converting them to Date would push them across day boundaries in other timezones.
+ */
+export declare class PriceIndexSnapshotEntry {
+    date: string;
+    competitorId: string;
+    priceIndex: number;
+    matchCount: number;
+    constructor(date: string, competitorId: string);
+    static parse(raw: ApiRecord): PriceIndexSnapshotEntry;
+}

package/dist/Pulse/Model/PriceIndexSnapshotEntry.js

@@ -0,0 +1,23 @@
+/**
+ * One competitor's price index on one day — the
+ * `/pulse/catalogs/:catalogId/statistics/price-index-history` resource.
+ *
+ * `date` stays the API's `YYYY-MM-DD` string rather than a Date: these are calendar buckets, and
+ * converting them to Date would push them across day boundaries in other timezones.
+ */
+export class PriceIndexSnapshotEntry {
+    date;
+    competitorId;
+    priceIndex = 0;
+    matchCount = 0;
+    constructor(date, competitorId) {
+        this.date = date;
+        this.competitorId = competitorId;
+    }
+    static parse(raw) {
+        const entry = new PriceIndexSnapshotEntry(raw.date, raw.competitor_id);
+        entry.priceIndex = Number(raw.price_index ?? 0);
+        entry.matchCount = Number(raw.match_count ?? 0);
+        return entry;
+    }
+}

package/dist/Pulse/Model/PriceSuggestion.d.ts

@@ -0,0 +1,29 @@
+import { ApiRecord } from '../../Model/ApiRecord.js';
+export type PriceSuggestionStatus = 'pending' | 'approved' | 'rejected';
+/**
+ * A proposed new price for one of the catalog's products — the `/pulse/price-suggestions` resource.
+ *
+ * Produced by a {@link PricingRule} (or by a strategy run directly, leaving `pricingRuleId` null).
+ * `reason` records the competitor prices the suggestion was derived from, so a reviewer can see why
+ * without re-deriving it. Approving one does not push the price: `appliedAt` is set once a flow has
+ * written it back to the shop.
+ */
+export declare class PriceSuggestion {
+    id: string;
+    catalogProductId: string;
+    pricingRuleId: string | null;
+    currentPrice: number;
+    suggestedPrice: number;
+    strategyName: string;
+    strategyDetails: string | null;
+    reason: Record<string, unknown> | null;
+    status: PriceSuggestionStatus;
+    createdAt: Date | null;
+    reviewedAt: Date | null;
+    reviewedBy: string | null;
+    appliedAt: Date | null;
+    constructor(id: string, catalogProductId: string);
+    /** Difference against the current price; negative means the suggestion is a price cut. */
+    get priceDifference(): number;
+    static parse(raw: ApiRecord): PriceSuggestion;
+}

package/dist/Pulse/Model/PriceSuggestion.js

@@ -0,0 +1,46 @@
+/**
+ * A proposed new price for one of the catalog's products — the `/pulse/price-suggestions` resource.
+ *
+ * Produced by a {@link PricingRule} (or by a strategy run directly, leaving `pricingRuleId` null).
+ * `reason` records the competitor prices the suggestion was derived from, so a reviewer can see why
+ * without re-deriving it. Approving one does not push the price: `appliedAt` is set once a flow has
+ * written it back to the shop.
+ */
+export class PriceSuggestion {
+    id;
+    catalogProductId;
+    pricingRuleId = null;
+    currentPrice = 0;
+    suggestedPrice = 0;
+    strategyName = '';
+    strategyDetails = null;
+    reason = null;
+    status = 'pending';
+    createdAt = null;
+    reviewedAt = null;
+    reviewedBy = null;
+    appliedAt = null;
+    constructor(id, catalogProductId) {
+        this.id = id;
+        this.catalogProductId = catalogProductId;
+    }
+    /** Difference against the current price; negative means the suggestion is a price cut. */
+    get priceDifference() {
+        return this.suggestedPrice - this.currentPrice;
+    }
+    static parse(raw) {
+        const suggestion = new PriceSuggestion(raw.id, raw.catalog_product);
+        suggestion.pricingRuleId = raw.pricing_rule ?? null;
+        suggestion.currentPrice = Number(raw.current_price ?? 0);
+        suggestion.suggestedPrice = Number(raw.suggested_price ?? 0);
+        suggestion.strategyName = raw.strategy_name ?? '';
+        suggestion.strategyDetails = raw.strategy_details ?? null;
+        suggestion.reason = raw.reason ?? null;
+        suggestion.status = raw.status ?? 'pending';
+        suggestion.createdAt = raw.created_at ? new Date(raw.created_at) : null;
+        suggestion.reviewedAt = raw.reviewed_at ? new Date(raw.reviewed_at) : null;
+        suggestion.reviewedBy = raw.reviewed_by ?? null;
+        suggestion.appliedAt = raw.applied_at ? new Date(raw.applied_at) : null;
+        return suggestion;
+    }
+}

package/dist/Pulse/Model/PricingRule.d.ts

@@ -0,0 +1,30 @@
+import { ApiRecord } from '../../Model/ApiRecord.js';
+/**
+ * A rule that proposes a new price for part of a catalog — the `/pulse/pricing-rules` resource.
+ *
+ * `conditions` decides which products it applies to and `actionType` / `actionParams` what it does
+ * to their price (match the cheapest competitor, undercut by a percentage, …). The floor and
+ * ceiling are guard rails the action may not cross, and `priority` breaks ties when several rules
+ * match the same product — lower runs first.
+ */
+export declare class PricingRule {
+    id: string;
+    catalogId: string;
+    name: string;
+    description: string | null;
+    productGroupId: string | null;
+    conditions: Record<string, unknown>;
+    actionType: string;
+    actionParams: Record<string, unknown>;
+    floorMargin: number | null;
+    floorPrice: number | null;
+    ceilingPrice: number | null;
+    /** Skip products with no cost price rather than pricing them without a margin guard. */
+    ignoreIfNoCostPrice: boolean;
+    priority: number;
+    isActive: boolean;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    constructor(id: string, catalogId: string, name: string);
+    static parse(raw: ApiRecord): PricingRule;
+}

package/dist/Pulse/Model/PricingRule.js

@@ -0,0 +1,49 @@
+/**
+ * A rule that proposes a new price for part of a catalog — the `/pulse/pricing-rules` resource.
+ *
+ * `conditions` decides which products it applies to and `actionType` / `actionParams` what it does
+ * to their price (match the cheapest competitor, undercut by a percentage, …). The floor and
+ * ceiling are guard rails the action may not cross, and `priority` breaks ties when several rules
+ * match the same product — lower runs first.
+ */
+export class PricingRule {
+    id;
+    catalogId;
+    name;
+    description = null;
+    productGroupId = null;
+    conditions = {};
+    actionType = '';
+    actionParams = {};
+    floorMargin = null;
+    floorPrice = null;
+    ceilingPrice = null;
+    /** Skip products with no cost price rather than pricing them without a margin guard. */
+    ignoreIfNoCostPrice = false;
+    priority = 0;
+    isActive = true;
+    createdAt = null;
+    updatedAt = null;
+    constructor(id, catalogId, name) {
+        this.id = id;
+        this.catalogId = catalogId;
+        this.name = name;
+    }
+    static parse(raw) {
+        const rule = new PricingRule(raw.id, raw.catalog, raw.name ?? '');
+        rule.description = raw.description ?? null;
+        rule.productGroupId = raw.product_group ?? null;
+        rule.conditions = raw.conditions ?? {};
+        rule.actionType = raw.action_type ?? '';
+        rule.actionParams = raw.action_params ?? {};
+        rule.floorMargin = raw.floor_margin ?? null;
+        rule.floorPrice = raw.floor_price ?? null;
+        rule.ceilingPrice = raw.ceiling_price ?? null;
+        rule.ignoreIfNoCostPrice = raw.ignore_if_no_cost_price === true;
+        rule.priority = Number(raw.priority ?? 0);
+        rule.isActive = raw.is_active !== false;
+        rule.createdAt = raw.created_at ? new Date(raw.created_at) : null;
+        rule.updatedAt = raw.updated_at ? new Date(raw.updated_at) : null;
+        return rule;
+    }
+}