rerobe-js-orm 4.8.7 → 4.9.0

package/lib/models/Merchant.d.ts

@@ -1,4 +1,35 @@
 import Base from '../Base';
+export type LabelTextSource = 'merchantName' | 'title' | 'price';
+export type LabelTextElement = {
+    source: LabelTextSource | string;
+    visible: boolean;
+    fontSize: number;
+    paddingTop: number;
+    transform: 'uppercase' | 'none' | string;
+};
+export type LabelBarcodeConfig = {
+    visible: boolean;
+    heightDots: number;
+    moduleWidth: 1 | 2;
+    paddingBottom: number;
+};
+export type LabelSkuConfig = {
+    visible: boolean;
+    fontSize: number;
+};
+export type LabelLayout = {
+    topElements: LabelTextElement[];
+    barcode: LabelBarcodeConfig;
+    sku: LabelSkuConfig;
+};
+export type LabelPrinterConfig = {
+    protocol: string;
+    widthMm: number;
+    heightMm: number;
+    dpi: number;
+    symbology: string;
+    layout: LabelLayout;
+};
 export default class Merchant extends Base {
     static MERCHANT_TYPES: {
         individual: string;
@@ -46,6 +77,58 @@ export default class Merchant extends Base {
         upgradeToStandalone: string;
     };
     static DEFAULT_MARKETPLACE_SELLER_CAPABILITIES: string[];
+    static LABEL_PRINTER_BARCODE_SYMBOLOGIES: {
+        code128: string;
+        ean13: string;
+    };
+    static LABEL_PRINTER_PROTOCOLS: {
+        zebraZpl: string;
+    };
+    static LABEL_PRINTER_CONFIG_DEFAULTS: {
+        protocol: string;
+        widthMm: number;
+        heightMm: number;
+        dpi: number;
+        symbology: string;
+        layout: {
+            topElements: {
+                source: string;
+                visible: boolean;
+                fontSize: number;
+                paddingTop: number;
+                transform: string;
+            }[];
+            barcode: {
+                visible: boolean;
+                heightDots: number;
+                moduleWidth: number;
+                paddingBottom: number;
+            };
+            sku: {
+                visible: boolean;
+                fontSize: number;
+            };
+        };
+    };
+    static DEFAULT_LABEL_LAYOUT: {
+        topElements: {
+            source: string;
+            visible: boolean;
+            fontSize: number;
+            paddingTop: number;
+            transform: string;
+        }[];
+        barcode: {
+            visible: boolean;
+            heightDots: number;
+            moduleWidth: number;
+            paddingBottom: number;
+        };
+        sku: {
+            visible: boolean;
+            fontSize: number;
+        };
+    };
     static INDUSTRY_TYPES: {
         beauty: string;
         clothing: string;
@@ -112,6 +195,8 @@ export default class Merchant extends Base {
     hasAutomatedPayouts?: boolean;
     hasAIQuickList?: boolean;
     hasReceiptPrinter?: boolean;
+    hasLabelPrinter?: boolean;
+    labelPrinterConfig?: LabelPrinterConfig;
     hasActiveWebshop?: boolean;
     stripeSubscription?: StripeSubscription;
     subscriptionStatus?: string;
@@ -124,6 +209,7 @@ export default class Merchant extends Base {
     featureAccess?: MerchantFeatureAccess | null;
     isMarketplaceSeller?: boolean;
     constructor(props?: any);
+    static normalizeLabelPrinterConfig(input?: Partial<LabelPrinterConfig> | Record<string, any> | null): LabelPrinterConfig;
     toObj(): MerchantObj;
     toMerchantMutableData(): MerchantMutableData;
     isManagedMarketplaceMerchant(): boolean;

package/lib/models/Merchant.js

@@ -90,6 +90,82 @@ class Merchant extends Base_1.default {
         if (props === null || props === void 0 ? void 0 : props.hasReceiptPrinter) {
             this.hasReceiptPrinter = props.hasReceiptPrinter;
         }
+        if (props === null || props === void 0 ? void 0 : props.hasLabelPrinter) {
+            this.hasLabelPrinter = props.hasLabelPrinter;
+        }
+        if ((props === null || props === void 0 ? void 0 : props.labelPrinterConfig) && typeof props.labelPrinterConfig === 'object') {
+            this.labelPrinterConfig = Merchant.normalizeLabelPrinterConfig(props.labelPrinterConfig);
+        }
+    }
+    // Coerce arbitrary input into a fully-populated, type-safe LabelPrinterConfig
+    // by layering it over the defaults. Migrates legacy `showFields` shapes
+    // into the new `layout` schema so older stored configs keep working.
+    static normalizeLabelPrinterConfig(input) {
+        const defaults = Merchant.LABEL_PRINTER_CONFIG_DEFAULTS;
+        const raw = (input || {});
+        const protocol = typeof raw.protocol === 'string' && raw.protocol ? raw.protocol : defaults.protocol;
+        const symbology = typeof raw.symbology === 'string' && raw.symbology ? raw.symbology : defaults.symbology;
+        const layout = (() => {
+            const fallback = defaults.layout;
+            const rawLayout = raw.layout && typeof raw.layout === 'object' ? raw.layout : null;
+            const legacyShowFields = raw.showFields && typeof raw.showFields === 'object' ? raw.showFields : null;
+            if (!rawLayout && legacyShowFields) {
+                return {
+                    topElements: fallback.topElements.map((el) => (Object.assign(Object.assign({}, el), { visible: legacyShowFields[el.source] !== false }))),
+                    barcode: Object.assign({}, fallback.barcode),
+                    sku: Object.assign(Object.assign({}, fallback.sku), { visible: legacyShowFields.sku !== false }),
+                };
+            }
+            if (!rawLayout) {
+                return {
+                    topElements: fallback.topElements.map((el) => (Object.assign({}, el))),
+                    barcode: Object.assign({}, fallback.barcode),
+                    sku: Object.assign({}, fallback.sku),
+                };
+            }
+            const rawTop = Array.isArray(rawLayout.topElements) ? rawLayout.topElements : [];
+            const topElements = rawTop
+                .map((entry, index) => {
+                if (!entry || typeof entry !== 'object')
+                    return null;
+                const fb = fallback.topElements.find((e) => e.source === entry.source) ||
+                    fallback.topElements[index] ||
+                    fallback.topElements[0];
+                return {
+                    source: typeof entry.source === 'string' ? entry.source : fb.source,
+                    visible: typeof entry.visible === 'boolean' ? entry.visible : fb.visible,
+                    fontSize: Number(entry.fontSize) > 0 ? Number(entry.fontSize) : fb.fontSize,
+                    paddingTop: Number(entry.paddingTop) >= 0 ? Number(entry.paddingTop) : fb.paddingTop,
+                    transform: entry.transform === 'uppercase' || entry.transform === 'none' ? entry.transform : fb.transform,
+                };
+            })
+                .filter(Boolean);
+            const rawBarcode = (rawLayout.barcode || {});
+            const barcode = {
+                visible: typeof rawBarcode.visible === 'boolean' ? rawBarcode.visible : fallback.barcode.visible,
+                heightDots: Number(rawBarcode.heightDots) > 0 ? Number(rawBarcode.heightDots) : fallback.barcode.heightDots,
+                moduleWidth: rawBarcode.moduleWidth === 2 ? 2 : 1,
+                paddingBottom: Number(rawBarcode.paddingBottom) >= 0 ? Number(rawBarcode.paddingBottom) : fallback.barcode.paddingBottom,
+            };
+            const rawSku = (rawLayout.sku || {});
+            const sku = {
+                visible: typeof rawSku.visible === 'boolean' ? rawSku.visible : fallback.sku.visible,
+                fontSize: Number(rawSku.fontSize) > 0 ? Number(rawSku.fontSize) : fallback.sku.fontSize,
+            };
+            return {
+                topElements: topElements.length > 0 ? topElements : fallback.topElements.map((el) => (Object.assign({}, el))),
+                barcode,
+                sku,
+            };
+        })();
+        return {
+            protocol,
+            widthMm: Number(raw.widthMm) > 0 ? Number(raw.widthMm) : defaults.widthMm,
+            heightMm: Number(raw.heightMm) > 0 ? Number(raw.heightMm) : defaults.heightMm,
+            dpi: Number(raw.dpi) > 0 ? Number(raw.dpi) : defaults.dpi,
+            symbology,
+            layout,
+        };
     }
     toObj() {
         const mObj = {
@@ -166,6 +242,12 @@ class Merchant extends Base_1.default {
         if (this.hasReceiptPrinter) {
             mObj.hasReceiptPrinter = this.hasReceiptPrinter;
         }
+        if (this.hasLabelPrinter) {
+            mObj.hasLabelPrinter = this.hasLabelPrinter;
+        }
+        if (this.labelPrinterConfig) {
+            mObj.labelPrinterConfig = this.labelPrinterConfig;
+        }
         if (this.organizationNumbers && Object.keys(this.organizationNumbers).length > 0) {
             mObj.organizationNumbers = this.organizationNumbers;
         }
@@ -222,6 +304,10 @@ Merchant.MERCHANT_ACCOUNT_CLASSES = merchant_constants_1.MERCHANT_ACCOUNT_CLASSE
 Merchant.MERCHANT_RELATIONSHIP_TYPES = merchant_constants_1.MERCHANT_RELATIONSHIP_TYPES;
 Merchant.MARKETPLACE_SELLER_CAPABILITIES = merchant_constants_1.MARKETPLACE_SELLER_CAPABILITIES;
 Merchant.DEFAULT_MARKETPLACE_SELLER_CAPABILITIES = merchant_constants_1.DEFAULT_MARKETPLACE_SELLER_CAPABILITIES;
+Merchant.LABEL_PRINTER_BARCODE_SYMBOLOGIES = merchant_constants_1.LABEL_PRINTER_BARCODE_SYMBOLOGIES;
+Merchant.LABEL_PRINTER_PROTOCOLS = merchant_constants_1.LABEL_PRINTER_PROTOCOLS;
+Merchant.LABEL_PRINTER_CONFIG_DEFAULTS = merchant_constants_1.LABEL_PRINTER_CONFIG_DEFAULTS;
+Merchant.DEFAULT_LABEL_LAYOUT = merchant_constants_1.DEFAULT_LABEL_LAYOUT;
 Merchant.INDUSTRY_TYPES = merchant_constants_1.INDUSTRY_TYPES;
 Merchant.UNIT_SYSTEM_TYPES = merchant_constants_1.UNIT_SYSTEM_TYPES;
 Merchant.METRIC_WEIGHT_TYPES = merchant_constants_1.METRIC_WEIGHT_TYPES;

package/lib/models/Product.d.ts

@@ -1,4 +1,5 @@
 import Base from '../Base';
+import { ProductPricing, TaxResolution, VariantPricing } from '../types/pricing-types';
 export default class Product extends Base {
     attributes: ProductAttributes;
     filterAttributes: ProductFilterAttributes;
@@ -9,6 +10,21 @@ export default class Product extends Base {
     constructor(props?: any);
     toPartialObj(): ShopifyProduct;
     toObj(): CompleteProduct;
+    isUntrackedStock(): boolean;
+    hasActiveMarketplaceListing(): boolean;
+    getActiveMarketplaceListings(): {
+        parentMarketplaceId: string;
+        listing: ProductMarketplaceListing;
+    }[];
+    getMarketplaceListingForParent(parentMarketplaceId: string): ProductMarketplaceListing | null;
+    isMarketplaceVisibleTo(parentMarketplaceId: string): boolean;
+    getResolvedTaxRate(countryCode: string): TaxResolution;
+    getPricing(countryCode: string): ProductPricing;
+    getVariantPricing(variantId: string, countryCode: string): VariantPricing | null;
+    getEffectiveSku(): string;
+    getEffectiveVariantSku(variantId: string): string;
+    describeVariant(variantId: string): string;
+    diagnoseVariantInventory(): 'no_variants' | 'all_zero_qty' | 'ok';
     toProductInputObjForShopify(location?: string): any;
     toProductInputObjForShopifyV2(locationId: string, weightUnit?: string): any[];
     /**

package/lib/models/Product.js

@@ -2,8 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const Base_1 = require("../Base");
 const product_constants_1 = require("../constants/product-constants");
+const marketplace_constants_1 = require("../constants/marketplace-constants");
 const options_1 = require("../form-states/Product/options");
 const ReRobeProductHelpers_1 = require("../helpers/ReRobeProductHelpers");
+const MarketplaceProductHelpers_1 = require("../helpers/MarketplaceProductHelpers");
+const PricingHelpers_1 = require("../helpers/PricingHelpers");
+const ProductSkuHelpers_1 = require("../helpers/ProductSkuHelpers");
 class Product extends Base_1.default {
     constructor(props) {
         super();
@@ -44,6 +48,7 @@ class Product extends Base_1.default {
             isTaxable: (props === null || props === void 0 ? void 0 : props.isTaxable) || '',
             taxCategory: (props === null || props === void 0 ? void 0 : props.taxCategory) || 'STANDARD',
             productClass: (props === null || props === void 0 ? void 0 : props.productClass) || 'UNIQUE',
+            marketplace: MarketplaceProductHelpers_1.default.normalizeMarketplace(props === null || props === void 0 ? void 0 : props.marketplace),
         };
         this.filterAttributes = {
             documentId: (props === null || props === void 0 ? void 0 : props.documentId) || this.utilities.makeRandId(28),
@@ -164,6 +169,112 @@ class Product extends Base_1.default {
         }
         return obj;
     }
+    // True for retail products that should be treated as having indefinite
+    // stock (cafe items, services, etc.). The web app marks these by writing
+    // `stockStatus = 'IN_STOCK_UNLIMITED'` on the product when the merchant
+    // toggles "Track stock" off in retail quick entry. Ordering, refund, and
+    // payout flows must skip per-location quantity decrements/restores when
+    // this returns true. Mirrors the legacy backend `isUntrackedStockProduct`
+    // shim so it lives in one place.
+    isUntrackedStock() {
+        return String(this.filterAttributes.stockStatus || '').trim() === marketplace_constants_1.STOCK_STATUSES.inStockUnlimited;
+    }
+    // Marketplace listing accessors — all return safe empty values when the
+    // product has no marketplace metadata, so legacy products are unaffected.
+    hasActiveMarketplaceListing() {
+        return this.getActiveMarketplaceListings().length > 0;
+    }
+    getActiveMarketplaceListings() {
+        const marketplace = MarketplaceProductHelpers_1.default.normalizeMarketplace(this.attributes.marketplace);
+        return Object.keys(marketplace.listings)
+            .map((parentMarketplaceId) => ({ parentMarketplaceId, listing: marketplace.listings[parentMarketplaceId] }))
+            .filter(({ listing }) => listing && listing.status !== marketplace_constants_1.MARKETPLACE_LISTING_STATUSES.removed);
+    }
+    getMarketplaceListingForParent(parentMarketplaceId) {
+        if (!parentMarketplaceId)
+            return null;
+        const marketplace = MarketplaceProductHelpers_1.default.normalizeMarketplace(this.attributes.marketplace);
+        return marketplace.listings[parentMarketplaceId] || null;
+    }
+    isMarketplaceVisibleTo(parentMarketplaceId) {
+        const listing = this.getMarketplaceListingForParent(parentMarketplaceId);
+        if (!listing)
+            return false;
+        return listing.status !== marketplace_constants_1.MARKETPLACE_LISTING_STATUSES.removed;
+    }
+    // Pricing accessors. Resolve once for the merchant's country and project
+    // every price-like field into both stored (net) and displayable (gross)
+    // forms. Backwards-compatible: legacy callers that read raw
+    // `attributes.price` continue to work; new callers can use these to get
+    // a single source of truth for gross/net display math without hand-
+    // rolling tax-rate lookups in every UI/service.
+    getResolvedTaxRate(countryCode) {
+        return PricingHelpers_1.default.resolveTaxRate({
+            countryCode,
+            taxCategory: this.attributes.taxCategory,
+            isTaxable: this.attributes.isTaxable,
+        });
+    }
+    getPricing(countryCode) {
+        return PricingHelpers_1.default.getProductPricing({
+            isTaxable: this.attributes.isTaxable,
+            taxCategory: this.attributes.taxCategory,
+            price: this.attributes.price,
+            salePrice: this.consignmentAttributes.salePrice,
+            compareAtPrice: this.attributes.compareAtPrice,
+            costPerItem: this.attributes.costPerItem,
+        }, { countryCode });
+    }
+    getVariantPricing(variantId, countryCode) {
+        const variants = (this.attributes.variantInventory || []);
+        const variant = variants.find((v) => v && v.id === variantId);
+        if (!variant)
+            return null;
+        return PricingHelpers_1.default.getVariantPricing(variant, {
+            isTaxable: this.attributes.isTaxable,
+            taxCategory: this.attributes.taxCategory,
+        }, { countryCode });
+    }
+    // SKU and variant-description accessors. Centralize the parent-SKU
+    // fallback and the human-readable options join so every label printer,
+    // receipt builder, and admin list view that surfaces a variant uses
+    // the same rule. Returns '' for missing SKUs / variants rather than
+    // throwing — callers were doing their own fallback anyway.
+    getEffectiveSku() {
+        return String(this.attributes.sku || '').trim();
+    }
+    getEffectiveVariantSku(variantId) {
+        const variants = (this.attributes.variantInventory || []);
+        const variant = variants.find((v) => v && v.id === variantId) || null;
+        return ProductSkuHelpers_1.default.effectiveVariantSku({ sku: this.attributes.sku }, variant);
+    }
+    describeVariant(variantId) {
+        const variants = (this.attributes.variantInventory || []);
+        const variant = variants.find((v) => v && v.id === variantId);
+        if (!variant)
+            return '';
+        return ProductSkuHelpers_1.default.describeVariantOptions(variant.options || {});
+    }
+    // Diagnose whether a variant-inventory product is purchasable. Mirrors
+    // the readiness gate the retail entry exposes as a confirm-before-save
+    // dialog: a multivariant product with no variants generated yet, or
+    // with every variant carrying zero across all locations, is technically
+    // savable but customers won't be able to buy anything from it. Returns
+    // 'ok' for non-multivariant products (single-row / unique inventory
+    // are handled by other checks).
+    diagnoseVariantInventory() {
+        const variants = (this.attributes.variantInventory || []);
+        if (this.attributes.productClass !== 'MULTIVARIANT')
+            return 'ok';
+        if (!variants.length)
+            return 'no_variants';
+        const allZero = variants.every((v) => {
+            const locs = Array.isArray(v === null || v === void 0 ? void 0 : v.locations) ? v.locations : [];
+            const total = locs.reduce((acc, loc) => acc + (Number(loc === null || loc === void 0 ? void 0 : loc.availableAmount) || 0), 0);
+            return total <= 0;
+        });
+        return allZero ? 'all_zero_qty' : 'ok';
+    }
     toProductInputObjForShopify(location) {
         const productInputObj = {
             title: this.attributes.title,
@@ -505,6 +616,7 @@ class Product extends Base_1.default {
         const createdAtTimestamp = this.utilities.sanitizeMillisTimeStamp(this.timestampAttributes.createdAtTimestamp);
         const { createdAtHour, createdAtDay, createdAtMonth, createdAtYear } = this.utilities.formatTimestamp(createdAtTimestamp);
         const [priceSold, commissionFee, productionFee, fulfillmentFee] = ReRobeProductHelpers_1.default.buildReRobeEarningsV2(this.toObj(), isCanonicalMerchant);
+        const marketplaceFields = MarketplaceProductHelpers_1.default.buildTypesenseFields(this.attributes.marketplace);
         const merchantValue = commissionFee + productionFee + fulfillmentFee;
         const sellerValue = priceSold - merchantValue;
         const calculatedCommission = merchantValue / priceSold;
@@ -523,6 +635,10 @@ class Product extends Base_1.default {
             isTaxable: this.utilities.sanitizeString(this.attributes.isTaxable),
             merchants: this.utilities.sanitzeStringArr(this.attributes.merchants),
             merchantId: this.utilities.sanitizeString(this.attributes.merchantId),
+            marketplaceVisibleToMerchantIds: marketplaceFields.marketplaceVisibleToMerchantIds,
+            marketplaceParentMerchantIds: marketplaceFields.marketplaceParentMerchantIds,
+            marketplaceRelationshipIds: marketplaceFields.marketplaceRelationshipIds,
+            isMarketplaceVisible: marketplaceFields.isMarketplaceVisible,
             price: this.utilities.sanitizeNumber(this.attributes.price),
             merchantValue: this.utilities.sanitizeNumber(merchantValue),
             sellerValue: this.utilities.sanitizeNumber(sellerValue),
@@ -979,6 +1095,30 @@ class Product extends Base_1.default {
                     name: 'merchants',
                     type: 'string[]',
                 },
+                {
+                    facet: false,
+                    optional: true,
+                    name: 'marketplaceVisibleToMerchantIds',
+                    type: 'string[]',
+                },
+                {
+                    facet: false,
+                    optional: true,
+                    name: 'marketplaceParentMerchantIds',
+                    type: 'string[]',
+                },
+                {
+                    facet: false,
+                    optional: true,
+                    name: 'marketplaceRelationshipIds',
+                    type: 'string[]',
+                },
+                {
+                    facet: true,
+                    optional: true,
+                    name: 'isMarketplaceVisible',
+                    type: 'bool',
+                },
                 {
                     facet: false,
                     optional: true,
@@ -1072,6 +1212,17 @@ class Product extends Base_1.default {
                     name: 'sku',
                     type: 'string',
                 },
+                {
+                    // Flat array of every non-empty `variantInventory[].sku` so a
+                    // scanner / search bar can resolve a variant-level barcode to
+                    // the parent product. Maintained by the onWriteProduct trigger
+                    // (projection of variantInventory.sku → variantSkus). Empty
+                    // array for single-SKU products.
+                    facet: true,
+                    optional: true,
+                    name: 'variantSkus',
+                    type: 'string[]',
+                },
                 {
                     facet: true,
                     optional: true,

package/lib/types/merchant-types.d.ts

@@ -52,11 +52,39 @@ type MerchantSystemOnlyMutableData = {
     hasAutomatedPayouts?: boolean;
     hasAIQuickList?: boolean;
     hasReceiptPrinter?: boolean;
+    hasLabelPrinter?: boolean;
+    labelPrinterConfig?: LabelPrinterConfigData;
     hasActiveWebshop?: boolean;
     subscriptionStatus?: string;
     channelPartners?: string[];
     isMarketplaceSeller?: boolean;
 };
+type LabelPrinterConfigData = {
+    protocol: string;
+    widthMm: number;
+    heightMm: number;
+    dpi: number;
+    symbology: string;
+    layout: {
+        topElements: {
+            source: string;
+            visible: boolean;
+            fontSize: number;
+            paddingTop: number;
+            transform: string;
+        }[];
+        barcode: {
+            visible: boolean;
+            heightDots: number;
+            moduleWidth: 1 | 2;
+            paddingBottom: number;
+        };
+        sku: {
+            visible: boolean;
+            fontSize: number;
+        };
+    };
+};
 type MerchantObj = MerchantMutableData & MerchantSystemOnlyMutableData;
 type MerchantTypes = 'INDIVIDUAL' | 'BUSINESS';
 type MerchantAccountMode = 'STANDALONE' | 'MANAGED';

package/lib/types/pricing-types.d.ts

@@ -0,0 +1,85 @@
+import { TaxCategoryValue } from '../constants/tax-constants';
+export type IsTaxableValue = 'yes' | 'no' | boolean | string | undefined | null;
+export interface CatalogRateInput {
+    countryCode: string;
+    taxCategory: string | null | undefined;
+    isTaxable: IsTaxableValue;
+}
+export interface FrozenRateInput {
+    taxRate: number | string | null | undefined;
+    isTaxable: IsTaxableValue;
+}
+export type RateInput = CatalogRateInput | FrozenRateInput;
+export interface TaxResolution {
+    rate: number;
+    category?: TaxCategoryValue;
+    taxable: boolean;
+}
+export interface ProductPricing {
+    rate: number;
+    taxable: boolean;
+    priceNet: string;
+    salePriceNet: string;
+    compareAtPriceNet: string;
+    costPerItemNet: string;
+    priceGross: string;
+    salePriceGross: string;
+    compareAtPriceGross: string;
+    costPerItemGross: string;
+}
+export interface VariantPricing {
+    rate: number;
+    taxable: boolean;
+    priceNet: string;
+    salePriceNet: string;
+    compareAtPriceNet: string;
+    costPerItemNet: string;
+    priceGross: string;
+    salePriceGross: string;
+    compareAtPriceGross: string;
+    costPerItemGross: string;
+}
+export interface OrderLinePricing {
+    rate: number;
+    taxable: boolean;
+    unitPriceNet: string;
+    unitPriceGross: string;
+    totalPriceNet: string;
+    totalPriceGross: string;
+    salePriceNet: string;
+    salePriceGross: string;
+}
+export interface ProductPricingLike {
+    isTaxable?: IsTaxableValue;
+    taxCategory?: string | null;
+    price?: string | number | null;
+    salePrice?: string | number | null;
+    compareAtPrice?: string | number | null;
+    costPerItem?: string | number | null;
+}
+export interface VariantPricingLike {
+    taxable?: IsTaxableValue;
+    price?: string | number | null;
+    salePrice?: string | number | null;
+    compareAtPrice?: string | number | null;
+    costPerItem?: string | number | null;
+}
+export interface OrderLinePricingLike {
+    isTaxable?: IsTaxableValue;
+    taxRate?: number | string | null;
+    originalUnitPrice?: {
+        amount?: number | string | null;
+    } | null;
+    originalTotalPrice?: {
+        amount?: number | string | null;
+    } | null;
+    salePrice?: {
+        amount?: number | string | null;
+    } | number | string | null;
+}
+export interface TaxCategoryOption {
+    value: string;
+    label: string;
+    rate: number;
+    rateLabel: string;
+}

package/lib/types/pricing-types.js

@@ -0,0 +1,5 @@
+"use strict";
+// Shared pricing types. Cross-cutting between Product (catalog) and Order
+// (frozen-rate) surfaces, kept dependency-free so they can be consumed by
+// helpers, models, and form-states without circular imports.
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/rerobe-order-types.d.ts

@@ -351,7 +351,93 @@ interface ReRobeOrderLineItem extends OrderLineItem {
     discountedPrice?: Money;
     taxAmountWithDiscount?: Money;
     handle?: string;
+    marketplace?: MarketplaceLineSnapshot;
 }
+type MarketplaceCommissionBasis = 'LINE_NET_EXCLUDING_TAX' | 'ORIGINAL_COMMISSION_SHARE' | string;
+type MarketplaceLineAmounts = {
+    lineNetAmount: number;
+    discountAmount: number;
+    taxableAmount: number;
+    taxAmount: number;
+    lineGrossAmount: number;
+    originalProductCommissionAmount: number;
+    marketplaceCommissionAmount: number;
+    stripeFeeAllocatedAmount: number;
+    ribbnFeeAllocatedAmount: number;
+    sellerProceedsAmount: number;
+    managedMerchantProceedsAmount: number;
+    marketplaceProceedsAmount: number;
+};
+type MarketplaceVariantSnapshot = {
+    variantId: string;
+    sku: string;
+    options: VariantOptions;
+    price: string;
+    compareAtPrice?: string | null;
+    salePrice?: string | null;
+    isOnSale?: 'yes' | 'no' | null;
+    taxable?: 'yes' | 'no' | null;
+    taxCategory: string;
+    locations: InventoryLocation[];
+};
+type MarketplaceLineSnapshot = {
+    isMarketplaceItem: boolean;
+    parentMerchantId: string;
+    managedMerchantId: string;
+    relationshipId: string;
+    productId: string;
+    variantId?: string;
+    sellerDisplayName?: string;
+    lineDisplayTitle?: string;
+    originalProductCommissionRate: string;
+    marketplaceCommissionRate: string;
+    marketplaceCommissionBasis: MarketplaceCommissionBasis;
+    quantity: number;
+    currencyCode: string;
+    amounts: MarketplaceLineAmounts;
+    variant?: MarketplaceVariantSnapshot;
+};
+type MarketplaceReturnAdjustment = {
+    quantityReturned: number;
+    amounts: MarketplaceLineAmounts;
+    remainingQuantity: number;
+};
+type MarketplaceLedgerStatus = 'PENDING_RETURN_PERIOD' | 'PAYABLE' | 'PAID_OUT' | 'RETURNED_BEFORE_PAYOUT' | 'REFUNDED_AFTER_PAYOUT' | 'TRANSFER_REVERSED' | string;
+type MarketplaceLedgerLifecycleTimestamps = {
+    createdAtTimestamp?: number | null;
+    pendingReturnPeriodAtTimestamp?: number | null;
+    payableAtTimestamp?: number | null;
+    paidOutAtTimestamp?: number | null;
+    returnedBeforePayoutAtTimestamp?: number | null;
+    refundedAfterPayoutAtTimestamp?: number | null;
+    transferReversedAtTimestamp?: number | null;
+    updatedAtTimestamp?: number | null;
+};
+type MarketplaceLedgerEntry = {
+    documentId?: string;
+    parentOrderId: string;
+    parentOrderLineItemId?: string;
+    parentMerchantId: string;
+    managedMerchantId: string;
+    relationshipId: string;
+    productId: string;
+    variantId?: string;
+    status: MarketplaceLedgerStatus;
+    snapshot: MarketplaceLineSnapshot;
+    returnDeadlineTimestamp?: number | null;
+    lifecycle: MarketplaceLedgerLifecycleTimestamps;
+};
+type MarketplaceFeeAllocation = {
+    lineKey: string;
+    amount: number;
+};
+type MarketplaceFeeBasketLine = {
+    lineKey: string;
+    sellerMerchantId: string;
+    lineNetAmount: number;
+    taxableAmount?: number;
+    quantity?: number;
+};
 type OrderLineItemConnection = {
     edges: OrderLineItemEdge[];
 };