rerobe-js-orm 4.8.8 → 4.9.0

package/lib/factories/Product/RetailProductFactory.js

@@ -0,0 +1,260 @@
+"use strict";
+// Retail product factory. Lifts the four `build*Payload` helpers from
+// `ribbn-web-app/components/admin/products-v2/RetailProductQuickEntry.tsx`
+// into ORM as four pure factory methods that produce canonical
+// seller-owned `Product` instances.
+//
+// Why this lives here:
+//   - The shape decisions (productClass, default status, default
+//     availableForSale, placeholder variant inventory, default
+//     reRobeCommission for marketplace sellers) are business logic, not
+//     UI plumbing — every surface that creates a retail product (web
+//     POS today, mobile / CSV uploader / backend service tomorrow)
+//     should produce the same shape.
+//   - Framework-agnostic: no Firestore, no React, no fetch. Persistence
+//     timestamps and the actual write are the caller's concern. Web
+//     keeps producing `serverTimestamp()` for `createdAtTimestamp` /
+//     `updatedAtTimestamp` and merging it into `factory.toObj()`.
+//   - Canonical marketplace shape: ownership is always seller-owned
+//     (`merchantId = vendorId = sellerMerchantId`,
+//     `merchants = [sellerMerchantId]`). Marketplace visibility for a
+//     parent is layered on top via
+//     `MarketplaceProductHelpers.upsertListing(...)` after construction
+//     — keeps this factory marketplace-aware-but-not-marketplace-coupled.
+Object.defineProperty(exports, "__esModule", { value: true });
+const product_constants_1 = require("../../constants/product-constants");
+const marketplace_constants_1 = require("../../constants/marketplace-constants");
+const MarketplaceProductHelpers_1 = require("../../helpers/MarketplaceProductHelpers");
+const ProductInventoryHelpers_1 = require("../../helpers/ProductInventoryHelpers");
+const ProductSkuHelpers_1 = require("../../helpers/ProductSkuHelpers");
+const tax_constants_1 = require("../../constants/tax-constants");
+const TaxHelpers_1 = require("../../helpers/TaxHelpers");
+const Product_1 = require("../../models/Product");
+class RetailProductFactory {
+    // ---- 4 public factory methods ----
+    static fromOneOfAKindClothing(input) {
+        const base = RetailProductFactory.buildBaseAttributes(input, product_constants_1.PRODUCT_CLASS_VALUES.UNIQUE);
+        const details = input.details || {};
+        const inventoryLocations = RetailProductFactory.buildInventoryLocationsForFixedQuantity(input.location, 1);
+        return new Product_1.default(Object.assign(Object.assign(Object.assign({}, base), RetailProductFactory.normalizeClothingDetails(details)), { quantity: 1, inventoryLocations }));
+    }
+    static fromMultivariantClothing(input) {
+        const base = RetailProductFactory.buildBaseAttributes(input, product_constants_1.PRODUCT_CLASS_VALUES.MULTIVARIANT);
+        const details = input.details || {};
+        const variantInventory = Array.isArray(input.variantInventory) ? input.variantInventory : [];
+        const aggregatedQuantity = RetailProductFactory.aggregateQuantityFromVariantInventory(variantInventory);
+        const inventoryLocations = RetailProductFactory.aggregateLocationsFromVariantInventory(variantInventory);
+        return new Product_1.default(Object.assign(Object.assign(Object.assign({}, base), RetailProductFactory.normalizeClothingDetails(details)), { variantInventory, quantity: aggregatedQuantity, inventoryLocations }));
+    }
+    static fromTrackedRetail(input) {
+        var _a, _b;
+        const base = RetailProductFactory.buildBaseAttributes(input, product_constants_1.PRODUCT_CLASS_VALUES.MULTIVARIANT);
+        const details = input.details || {};
+        const sku = base.sku;
+        const numericQuantity = RetailProductFactory.coerceNonNegativeQuantity(input.quantity);
+        const placeholderVariant = ProductInventoryHelpers_1.default.buildPlaceholderVariantInventory({
+            sku,
+            price: base.price,
+            taxable: input.variantTaxable || base.isTaxable,
+            quantity: numericQuantity,
+            locationId: (_a = input.location) === null || _a === void 0 ? void 0 : _a.locationId,
+            locationName: (_b = input.location) === null || _b === void 0 ? void 0 : _b.locationName,
+            continueSellingWhenOutOfStock: false,
+        });
+        const inventoryLocations = RetailProductFactory.buildInventoryLocationsForFixedQuantity(input.location, numericQuantity);
+        return new Product_1.default(Object.assign(Object.assign(Object.assign({}, base), RetailProductFactory.normalizeNonClothingDetails(details)), { variantInventory: placeholderVariant, inventoryLocations, quantity: numericQuantity }));
+    }
+    static fromUntrackedRetail(input) {
+        var _a, _b;
+        const base = RetailProductFactory.buildBaseAttributes(input, product_constants_1.PRODUCT_CLASS_VALUES.MULTIVARIANT);
+        const details = input.details || {};
+        const sku = base.sku;
+        const placeholderVariant = ProductInventoryHelpers_1.default.buildPlaceholderVariantInventory({
+            sku,
+            price: base.price,
+            taxable: base.isTaxable,
+            quantity: 0,
+            locationId: (_a = input.location) === null || _a === void 0 ? void 0 : _a.locationId,
+            locationName: (_b = input.location) === null || _b === void 0 ? void 0 : _b.locationName,
+            continueSellingWhenOutOfStock: true,
+        });
+        const inventoryLocations = RetailProductFactory.buildInventoryLocationsForFixedQuantity(input.location, 0);
+        return new Product_1.default(Object.assign(Object.assign(Object.assign({}, base), RetailProductFactory.normalizeNonClothingDetails(details)), { variantInventory: placeholderVariant, inventoryLocations, quantity: 0, 
+            // Sentinel that signals the order processor / inventory policy to
+            // skip per-location decrements for this product.
+            stockStatus: marketplace_constants_1.STOCK_STATUSES.inStockUnlimited }));
+    }
+    // ---- Shared helpers (exposed as static so callers / tests can use them) ----
+    static resolveOwnership(ownership) {
+        const sellerMerchantId = String((ownership === null || ownership === void 0 ? void 0 : ownership.sellerMerchantId) || '').trim();
+        if (!sellerMerchantId) {
+            throw new Error('RetailProductFactory: ownership.sellerMerchantId is required');
+        }
+        const ownershipShape = MarketplaceProductHelpers_1.default.buildSellerProductOwnership({ sellerMerchantId });
+        return Object.assign(Object.assign({}, ownershipShape), { vendorName: (ownership === null || ownership === void 0 ? void 0 : ownership.sellerMerchantName) || '' });
+    }
+    static resolveDefaults(ownership) {
+        const isMarketplaceSeller = !!(ownership === null || ownership === void 0 ? void 0 : ownership.isMarketplaceSeller);
+        return {
+            status: isMarketplaceSeller ? product_constants_1.PRODUCT_STATES.listed : product_constants_1.PRODUCT_STATES.draft,
+            availableForSale: isMarketplaceSeller,
+        };
+    }
+    static resolveAccounting(accounting, ownership) {
+        var _a, _b, _c;
+        const normalizedTaxCategory = TaxHelpers_1.default.normalizeTaxCategory(accounting === null || accounting === void 0 ? void 0 : accounting.taxCategory);
+        const isTaxable = (accounting === null || accounting === void 0 ? void 0 : accounting.isTaxable) !== undefined
+            ? accounting.isTaxable
+            : normalizedTaxCategory === tax_constants_1.TAX_CATEGORIES.EXEMPT
+                ? 'no'
+                : 'yes';
+        const reRobeCommission = (accounting === null || accounting === void 0 ? void 0 : accounting.reRobeCommission) !== undefined
+            ? accounting.reRobeCommission
+            : (ownership === null || ownership === void 0 ? void 0 : ownership.isMarketplaceSeller)
+                ? MarketplaceProductHelpers_1.default.defaultSellerCommission()
+                : undefined;
+        return {
+            price: String((_a = accounting === null || accounting === void 0 ? void 0 : accounting.price) !== null && _a !== void 0 ? _a : '').trim(),
+            taxCategory: String(normalizedTaxCategory),
+            isTaxable,
+            costPerItem: String((_b = accounting === null || accounting === void 0 ? void 0 : accounting.costPerItem) !== null && _b !== void 0 ? _b : '').trim(),
+            compareAtPrice: String((_c = accounting === null || accounting === void 0 ? void 0 : accounting.compareAtPrice) !== null && _c !== void 0 ? _c : '').trim(),
+            reRobeCommission,
+        };
+    }
+    // ---- Private helpers ----
+    static buildBaseAttributes(input, productClass) {
+        const ownership = RetailProductFactory.resolveOwnership(input.ownership);
+        const defaults = RetailProductFactory.resolveDefaults(input.ownership);
+        const accounting = RetailProductFactory.resolveAccounting(input.accounting, input.ownership);
+        const sku = String(input.sku || '').trim() || ProductSkuHelpers_1.default.generateSku();
+        const title = String(input.title || '').trim();
+        const base = {
+            title,
+            sku,
+            productClass,
+            price: accounting.price,
+            taxCategory: accounting.taxCategory,
+            isTaxable: accounting.isTaxable,
+            costPerItem: accounting.costPerItem,
+            compareAtPrice: accounting.compareAtPrice,
+            vendorId: ownership.vendorId,
+            vendorName: ownership.vendorName,
+            merchantId: ownership.merchantId,
+            merchants: ownership.merchants,
+            status: defaults.status,
+            availableForSale: defaults.availableForSale,
+            imageUrls: Array.isArray(input.imageUrls) ? input.imageUrls : [],
+            coverPhotoUrl: input.coverPhotoUrl || '',
+            tags: Array.isArray(input.tags) ? input.tags : [],
+        };
+        if (accounting.reRobeCommission !== undefined) {
+            base.reRobeCommission = accounting.reRobeCommission;
+        }
+        return base;
+    }
+    static normalizeClothingDetails(details) {
+        const out = {};
+        if (details.brand !== undefined)
+            out.brand = details.brand;
+        if (details.gender !== undefined)
+            out.gender = details.gender;
+        if (details.productCategory !== undefined)
+            out.productCategory = details.productCategory;
+        if (details.productType !== undefined)
+            out.productType = details.productType;
+        if (details.color !== undefined)
+            out.color = details.color;
+        if (details.size !== undefined)
+            out.size = details.size;
+        if (details.productStyle !== undefined)
+            out.productStyle = details.productStyle;
+        if (details.materialComposition !== undefined)
+            out.materialComposition = details.materialComposition;
+        if (details.measurementCategory !== undefined)
+            out.measurementCategory = details.measurementCategory;
+        if (details.standardSize !== undefined)
+            out.standardSize = details.standardSize;
+        if (details.internationalSize !== undefined)
+            out.internationalSize = details.internationalSize;
+        if (details.condition !== undefined)
+            out.condition = details.condition;
+        if (details.conditionRemarks !== undefined)
+            out.conditionRemarks = details.conditionRemarks;
+        if (details.productRemarks !== undefined)
+            out.productRemarks = details.productRemarks;
+        if (details.careInstructions !== undefined)
+            out.careInstructions = details.careInstructions;
+        if (details.description !== undefined)
+            out.description = details.description;
+        return out;
+    }
+    static normalizeNonClothingDetails(details) {
+        const out = {};
+        if (details.brand !== undefined)
+            out.brand = details.brand;
+        if (details.productCategory !== undefined)
+            out.productCategory = details.productCategory;
+        if (details.description !== undefined)
+            out.description = details.description;
+        return out;
+    }
+    static buildInventoryLocationsForFixedQuantity(location, quantity) {
+        const locationId = String((location === null || location === void 0 ? void 0 : location.locationId) || '').trim();
+        if (!locationId)
+            return [];
+        const safeQty = RetailProductFactory.coerceNonNegativeQuantity(quantity);
+        return [
+            {
+                id: locationId,
+                name: (location === null || location === void 0 ? void 0 : location.locationName) || '',
+                incomingAmount: 0,
+                availableAmount: safeQty,
+            },
+        ];
+    }
+    static coerceNonNegativeQuantity(value) {
+        const n = typeof value === 'number' ? value : Number(value);
+        if (!Number.isFinite(n))
+            return 0;
+        return Math.max(0, Math.floor(n));
+    }
+    // For multivariant clothing, sum availableAmount across every variant
+    // and every variant location so the parent `quantity` field stays in
+    // sync with the reality the inventory rows describe. Mirrors the
+    // aggregation `ProductFormState.aggregateInventoryLocationsFromVariants`
+    // does at edit time.
+    static aggregateQuantityFromVariantInventory(variantInventory) {
+        return variantInventory.reduce((acc, v) => {
+            const locations = Array.isArray(v === null || v === void 0 ? void 0 : v.locations) ? v.locations : [];
+            const variantSum = locations.reduce((lacc, loc) => lacc + (Number(loc === null || loc === void 0 ? void 0 : loc.availableAmount) || 0), 0);
+            return acc + variantSum;
+        }, 0);
+    }
+    // For multivariant clothing, project the parent `inventoryLocations`
+    // by summing per-location availableAmount across every variant. Matches
+    // the form-state aggregation rule one-for-one.
+    static aggregateLocationsFromVariantInventory(variantInventory) {
+        const acc = {};
+        variantInventory.forEach((v) => {
+            const locations = Array.isArray(v === null || v === void 0 ? void 0 : v.locations) ? v.locations : [];
+            locations.forEach((loc) => {
+                const id = String((loc === null || loc === void 0 ? void 0 : loc.id) || '').trim();
+                if (!id)
+                    return;
+                if (!acc[id]) {
+                    acc[id] = {
+                        id,
+                        name: (loc === null || loc === void 0 ? void 0 : loc.name) || '',
+                        incomingAmount: 0,
+                        availableAmount: 0,
+                    };
+                }
+                acc[id].availableAmount = acc[id].availableAmount + (Number(loc === null || loc === void 0 ? void 0 : loc.availableAmount) || 0);
+                acc[id].incomingAmount = acc[id].incomingAmount + (Number(loc === null || loc === void 0 ? void 0 : loc.incomingAmount) || 0);
+            });
+        });
+        return Object.keys(acc).map((id) => acc[id]);
+    }
+}
+exports.default = RetailProductFactory;

package/lib/form-states/Product/ProductFormState.d.ts

@@ -75,6 +75,15 @@ export default class ProductFormState extends FormState {
     addAxisValue(axis: string, value: string): void;
     removeAxisValue(axis: string, value: string): void;
     reorderAxes(order: string[]): void;
+    applyVariantAxes(opts: {
+        axes: {
+            [axis: string]: string[];
+        };
+        defaults?: Partial<VariantInventory>;
+    }): void;
+    deriveAxesFromVariantInventory(): {
+        [axis: string]: string[];
+    };
     upsertVariantByOptions(options: {
         [k: string]: string;
     }, patch: Partial<VariantInventory>): void;

package/lib/form-states/Product/ProductFormState.js

@@ -790,6 +790,52 @@ class ProductFormState extends FormState_1.default {
         this.variantAxes = next;
         // No regen required; only presentation order
     }
+    // Convenience wrapper used by retail entry surfaces that drive variants
+    // from a small number of axes (e.g. just Size + Color). Trims and
+    // dedupes axis values, drops empty axes, then runs the axis update +
+    // regenerate pipeline in one shot. Empty axes input is a no-op so the
+    // form-state stays untouched if the merchant clears the dropdowns.
+    applyVariantAxes(opts) {
+        const inputAxes = (opts === null || opts === void 0 ? void 0 : opts.axes) || {};
+        const cleaned = {};
+        Object.keys(inputAxes).forEach((axisName) => {
+            const values = Array.isArray(inputAxes[axisName]) ? inputAxes[axisName] : [];
+            const cleanedValues = Array.from(new Set(values.map((v) => String(v).trim()).filter(Boolean)));
+            if (cleanedValues.length > 0) {
+                cleaned[axisName] = cleanedValues;
+            }
+        });
+        this.setVariantAxes(cleaned);
+        this.generateVariantsFromAxes((opts === null || opts === void 0 ? void 0 : opts.defaults) || {});
+    }
+    // Reverse of applyVariantAxes — read the current variantInventory rows
+    // and project them back to a per-axis values map. Used by simplified
+    // retail flows to hydrate local axis dropdowns from a product loaded
+    // for editing. Preserves first-seen order so the UI doesn't reshuffle
+    // values across renders.
+    deriveAxesFromVariantInventory() {
+        var _a;
+        const variants = (((_a = this.fields.variantInventory) === null || _a === void 0 ? void 0 : _a.selectedValues) || []);
+        const acc = {};
+        const seen = {};
+        variants.forEach((v) => {
+            const opts = (v === null || v === void 0 ? void 0 : v.options) || {};
+            Object.keys(opts).forEach((axisName) => {
+                const value = String(opts[axisName] || '').trim();
+                if (!value)
+                    return;
+                if (!acc[axisName]) {
+                    acc[axisName] = [];
+                    seen[axisName] = new Set();
+                }
+                if (!seen[axisName].has(value)) {
+                    seen[axisName].add(value);
+                    acc[axisName].push(value);
+                }
+            });
+        });
+        return acc;
+    }
     upsertVariantByOptions(options, patch) {
         const prev = this.getExistingVariantByOptions(options);
         const id = (prev === null || prev === void 0 ? void 0 : prev.id) || this.utilities.makeRandId(28);

package/lib/helpers/MarketplaceProductHelpers.d.ts

@@ -0,0 +1,181 @@
+import { MarketplaceCommissionBasisValue, MarketplaceFeeAllocationBasisValue, MarketplaceListingStatusValue, MarketplaceRelationshipTypeValue } from '../constants/marketplace-constants';
+import { CommissionPolicy } from './marketplace/CommissionPolicy';
+import { FeeAllocationContext, FeeAllocationPolicy } from './marketplace/FeeAllocationPolicy';
+import { InventoryAdjustmentParams, InventoryAdjustmentResult, InventoryPolicy } from './marketplace/InventoryPolicy';
+export { CommissionPolicy, CommissionPolicyContext, CommissionPolicyFeeContext, CommissionPolicyResult, } from './marketplace/CommissionPolicy';
+export { FeeAllocationContext, FeeAllocationPolicy } from './marketplace/FeeAllocationPolicy';
+export { InventoryAdjustmentParams, InventoryAdjustmentResult, InventoryPolicy } from './marketplace/InventoryPolicy';
+export { MarketplaceCommissionRateError, MarketplaceOwnershipError } from './marketplace/MarketplaceErrors';
+type BuildMarketplaceListingParams = {
+    productMerchantId?: string;
+    listings?: {
+        parentMarketplaceId: string;
+        relationshipId: string;
+        relationshipType?: string;
+        status?: MarketplaceListingStatusValue | string;
+        listedAt?: number | null;
+        updatedAt?: number | null;
+    }[];
+};
+type VariantSelectionInput = {
+    variantId?: string;
+    options?: VariantOptions;
+};
+type BuildMarketplaceLineSnapshotParams = {
+    product: CompleteProduct;
+    parentMerchantId: string;
+    managedMerchantId?: string;
+    relationshipId: string;
+    sellerDisplayName?: string;
+    lineDisplayTitle?: string;
+    marketplaceCommissionRate: string | number;
+    originalProductCommissionRate?: string | number;
+    marketplaceCommissionBasis?: MarketplaceCommissionBasisValue | string;
+    quantity?: number;
+    currencyCode?: string;
+    discountAmount?: number;
+    taxAmount?: number;
+    stripeFeeAllocatedAmount?: number;
+    ribbnFeeAllocatedAmount?: number;
+    variantSelection?: VariantSelectionInput;
+};
+type MarketplaceRelationshipInput = {
+    documentId?: string;
+    parentMerchantId?: string;
+    childMerchantId?: string;
+    marketplaceCommission?: string | number;
+    marketplaceCommissionBasis?: MarketplaceCommissionBasisValue | string;
+    isActive?: boolean;
+    relationshipType?: string;
+};
+type BuildCanonicalMarketplaceListingPatchParams = {
+    product: CompleteProduct;
+    parentMerchantId: string;
+    relationshipId?: string;
+    relationshipType?: MarketplaceRelationshipTypeValue | string;
+    listingStatus?: MarketplaceListingStatusValue | string;
+    at?: number;
+};
+type BuildLineSnapshotFromListingParams = {
+    product: CompleteProduct;
+    parentMerchantId: string;
+    relationship?: MarketplaceRelationshipInput | null;
+    lineItem?: ReRobeOrderLineItem | any;
+    quantity?: number;
+    currencyCode?: string;
+    marketplaceCommissionRate?: string | number;
+    originalProductCommissionRate?: string | number;
+    marketplaceCommissionBasis?: MarketplaceCommissionBasisValue | string;
+    discountAmount?: number;
+    taxAmount?: number;
+    stripeFeeAllocatedAmount?: number;
+    ribbnFeeAllocatedAmount?: number;
+    variantSelection?: VariantSelectionInput;
+};
+type InventoryTransformParams = {
+    product: CompleteProduct;
+    variantId: string;
+    locationId?: string;
+    quantity?: number;
+};
+type ReturnAdjustmentParams = {
+    snapshot: MarketplaceLineSnapshot;
+    quantityReturned?: number;
+};
+type ApplyEffectiveCommissionToProductsParams = {
+    products: CompleteProduct[];
+    relationships?: MarketplaceRelationshipInput[];
+    contextMerchantId?: string;
+};
+type ApplyStripeFeeRecoupBumpToProductsParams = {
+    merchantId: string;
+    products: CompleteProduct[];
+    totalFeeAmount: number;
+    basis?: MarketplaceFeeAllocationBasisValue | string;
+};
+export default class MarketplaceProductHelpers {
+    static registerCommissionPolicy(policy: CommissionPolicy): void;
+    static getCommissionPolicy(basis: string): CommissionPolicy;
+    static hasCommissionPolicy(basis: string): boolean;
+    static emptyMarketplace(): ProductMarketplace;
+    static uniqueStrings(values?: any[]): string[];
+    static normalizeMarketplace(input?: any): ProductMarketplace;
+    static buildMarketplace({ productMerchantId, listings, }: BuildMarketplaceListingParams): ProductMarketplace;
+    static buildTypesenseFields(marketplace?: ProductMarketplace): {
+        marketplaceVisibleToMerchantIds: string[];
+        marketplaceParentMerchantIds: string[];
+        marketplaceRelationshipIds: string[];
+        isMarketplaceVisible: boolean;
+    };
+    static toRate(value: string | number | undefined | null): number;
+    static roundMoney(value: number): number;
+    static lineNetFromProduct(product: CompleteProduct, quantity?: number, variant?: MarketplaceVariantSnapshot): number;
+    static selectVariant(product: CompleteProduct, selection?: VariantSelectionInput): MarketplaceVariantSnapshot | null;
+    static buildLineSnapshot({ product, parentMerchantId, managedMerchantId, relationshipId, sellerDisplayName, lineDisplayTitle, marketplaceCommissionRate, originalProductCommissionRate, marketplaceCommissionBasis, quantity, currencyCode, discountAmount, taxAmount, stripeFeeAllocatedAmount, ribbnFeeAllocatedAmount, variantSelection, }: BuildMarketplaceLineSnapshotParams): MarketplaceLineSnapshot;
+    static deriveVariantSelectionFromLineItem(lineItem: any): VariantSelectionInput | undefined;
+    static buildLineSnapshotFromListing({ product, parentMerchantId, relationship, lineItem, quantity, currencyCode, marketplaceCommissionRate, originalProductCommissionRate, marketplaceCommissionBasis, discountAmount, taxAmount, stripeFeeAllocatedAmount, ribbnFeeAllocatedAmount, variantSelection, }: BuildLineSnapshotFromListingParams): MarketplaceLineSnapshot | null;
+    static prorateAmounts(amounts: MarketplaceLineAmounts, ratio: number): MarketplaceLineAmounts;
+    static buildReturnAdjustment({ snapshot, quantityReturned }: ReturnAdjustmentParams): MarketplaceReturnAdjustment;
+    static transformVariantInventory({ product, variantId, locationId, quantity }: InventoryTransformParams, direction: 'decrement' | 'restore'): VariantInventory[];
+    static decrementVariantInventory(params: InventoryTransformParams): VariantInventory[];
+    static restoreVariantInventory(params: InventoryTransformParams): VariantInventory[];
+    static registerInventoryPolicy(policy: InventoryPolicy, position?: 'append' | 'prepend'): void;
+    static findInventoryPolicy(product: CompleteProduct | null | undefined): InventoryPolicy | null;
+    static adjustInventory(product: CompleteProduct, params: InventoryAdjustmentParams, direction: 'decrement' | 'restore'): InventoryAdjustmentResult;
+    static adjustVariantInventoryForLine(product: CompleteProduct, { lineItem, variantId, locationId, defaultLocationId, quantity, }: {
+        lineItem?: any;
+        variantId?: string;
+        locationId?: string;
+        defaultLocationId?: string;
+        quantity?: number;
+    }, direction?: 'decrement' | 'restore'): InventoryAdjustmentResult;
+    static registerFeeAllocationPolicy(policy: FeeAllocationPolicy): void;
+    static getFeeAllocationPolicy(basis: string): FeeAllocationPolicy;
+    static allocateFee(context: FeeAllocationContext, basis?: MarketplaceFeeAllocationBasisValue | string): MarketplaceFeeAllocation[];
+    static allocateStripeFee(context: FeeAllocationContext): MarketplaceFeeAllocation[];
+    static allocateRibbnFee(context: FeeAllocationContext): MarketplaceFeeAllocation[];
+    static buildFeeBasketFromProducts({ merchantId, products, }: {
+        merchantId: string;
+        products: CompleteProduct[];
+    }): MarketplaceFeeBasketLine[];
+    static applyStripeFeeRecoupBumpToProducts({ merchantId, products, totalFeeAmount, basis, }: ApplyStripeFeeRecoupBumpToProductsParams): CompleteProduct[];
+    static upsertListing(marketplace: ProductMarketplace | undefined, parentMarketplaceId: string, partial?: Partial<ProductMarketplaceListing> & {
+        ownerMerchantId?: string;
+    }, options?: {
+        at?: number;
+    }): ProductMarketplace;
+    static pauseListing(marketplace: ProductMarketplace | undefined, parentMarketplaceId: string, options?: {
+        at?: number;
+        ownerMerchantId?: string;
+    }): ProductMarketplace;
+    static resumeListing(marketplace: ProductMarketplace | undefined, parentMarketplaceId: string, options?: {
+        at?: number;
+        ownerMerchantId?: string;
+    }): ProductMarketplace;
+    static removeListing(marketplace: ProductMarketplace | undefined, parentMarketplaceId: string, options?: {
+        at?: number;
+        ownerMerchantId?: string;
+    }): ProductMarketplace;
+    static buildCanonicalMarketplaceListingPatch({ product, parentMerchantId, relationshipId, relationshipType, listingStatus, at, }: BuildCanonicalMarketplaceListingPatchParams): {
+        marketplace: ProductMarketplace;
+    } | null;
+    static resolveEffectiveCommission(product: CompleteProduct | null | undefined, relationship: {
+        marketplaceCommission?: string | number;
+        isActive?: boolean;
+        relationshipType?: string;
+        parentMerchantId?: string;
+    } | null | undefined, contextMerchantId?: string): string;
+    static applyEffectiveCommissionToProducts({ products, relationships, contextMerchantId, }: ApplyEffectiveCommissionToProductsParams): CompleteProduct[];
+    static buildSellerProductOwnership(params: {
+        sellerMerchantId: string;
+        isActingAs?: boolean;
+        parentMerchantId?: string;
+    }): {
+        merchantId: string;
+        vendorId: string;
+        merchants: string[];
+    };
+    static defaultSellerCommission(): string;
+    static buildActAsTypesenseFilter(managedMerchantId: string): string;
+    static normalizeCommissionRate(value: string | number | null | undefined): string;
+}