@openlup/platform 0.17.0 → 0.19.0

package/dist/pricing/contracts/offer.d.ts

@@ -0,0 +1,52 @@
+import type { CommerceMoney } from "./money.js";
+import type { PricingPolicySnapshot } from "./offerPolicy.js";
+export declare const COMMERCE_OFFER_PRICING_CONTRACT_VERSION: "commerce.offer-pricing.v1";
+export declare const COMMERCE_OFFER_PRICING_V2_CONTRACT_VERSION: "commerce.offer-pricing.v2";
+export interface CommerceOfferPrice {
+    packageGross: CommerceMoney;
+    unitGross: CommerceMoney;
+}
+export interface CommerceProductOfferPricing {
+    productSlug: string;
+    unitCount: number;
+    oneTime: CommerceOfferPrice;
+    subscriptionInitial: CommerceOfferPrice;
+    subscriptionRecurring: CommerceOfferPrice;
+    catalogAnchorUnitGross: CommerceMoney;
+    initialDiscountPercent: number;
+    recurringDiscountPercent: number;
+}
+export type CommerceOfferPricingResponse<ScopeV1 extends string = string, ScopeV2 extends string = string> = {
+    contractVersion: typeof COMMERCE_OFFER_PRICING_CONTRACT_VERSION;
+    scope: ScopeV1;
+    products: CommerceProductOfferPricing[];
+    minimum: {
+        oneTime: CommerceProductOfferPricing;
+        subscription: CommerceProductOfferPricing;
+    };
+} | {
+    contractVersion: typeof COMMERCE_OFFER_PRICING_V2_CONTRACT_VERSION;
+    scope: ScopeV2;
+    products: CommerceProductOfferPricing[];
+    minimum: {
+        oneTime: CommerceProductOfferPricing;
+        subscription: CommerceProductOfferPricing;
+    };
+    pricingPolicy: PricingPolicySnapshot;
+    shipping: {
+        gross: CommerceMoney;
+        discountGross: CommerceMoney;
+        payable: CommerceMoney;
+    };
+    minimumProductPayable: CommerceMoney;
+};
+/** Complete opt-in v3 response; the incumbent v1/v2 union stays unchanged. */
+export declare const COMMERCE_OFFER_PRICING_V3_CONTRACT_VERSION: "commerce.offer-pricing.v3";
+export type AcquisitionOfferPricingResponse<ScopeV2 extends string = string> = Omit<Extract<CommerceOfferPricingResponse<string, ScopeV2>, {
+    contractVersion: typeof COMMERCE_OFFER_PRICING_V2_CONTRACT_VERSION;
+}>, "contractVersion"> & {
+    contractVersion: typeof COMMERCE_OFFER_PRICING_V3_CONTRACT_VERSION;
+    acquisitionTerms: import("./acquisitionTerms.js").AcquisitionTerms;
+    observedAt: string;
+    validUntil: string;
+};

package/dist/pricing/contracts/offer.js

@@ -0,0 +1,4 @@
+export const COMMERCE_OFFER_PRICING_CONTRACT_VERSION = "commerce.offer-pricing.v1";
+export const COMMERCE_OFFER_PRICING_V2_CONTRACT_VERSION = "commerce.offer-pricing.v2";
+/** Complete opt-in v3 response; the incumbent v1/v2 union stays unchanged. */
+export const COMMERCE_OFFER_PRICING_V3_CONTRACT_VERSION = "commerce.offer-pricing.v3";

package/dist/pricing/contracts/offerPolicy.d.ts

@@ -0,0 +1,16 @@
+export declare const OFFER_POLICY_V1: "commerce.offer-policy.v1";
+export declare const OFFER_POLICY_V2: "commerce.offer-policy.v2";
+export declare const PROMOTION_ENGINE_V1: "promotion-engine.v1";
+export declare const PROMOTION_ENGINE_V2: "promotion-engine.v2";
+export declare const OFFER_POLICY_V2_CAPABILITY: "commerce.offer-policy.v2";
+export type OfferPolicyVersion = typeof OFFER_POLICY_V1 | typeof OFFER_POLICY_V2;
+export type PromotionEngineVersion = typeof PROMOTION_ENGINE_V1 | typeof PROMOTION_ENGINE_V2;
+export interface PricingPolicyRequest {
+    capability?: typeof OFFER_POLICY_V2_CAPABILITY;
+    token?: string;
+}
+export interface PricingPolicySnapshot {
+    offerPolicyVersion: OfferPolicyVersion;
+    promotionEngineVersion: PromotionEngineVersion;
+    pricingPolicyToken?: string;
+}

package/dist/pricing/contracts/offerPolicy.js

@@ -0,0 +1,5 @@
+export const OFFER_POLICY_V1 = "commerce.offer-policy.v1";
+export const OFFER_POLICY_V2 = "commerce.offer-policy.v2";
+export const PROMOTION_ENGINE_V1 = "promotion-engine.v1";
+export const PROMOTION_ENGINE_V2 = "promotion-engine.v2";
+export const OFFER_POLICY_V2_CAPABILITY = OFFER_POLICY_V2;

package/dist/pricing/contracts/policy.d.ts

@@ -0,0 +1,22 @@
+export declare const SUBSCRIPTION_PRICE_POLICY_SCHEMA_VERSION = "subscription-price-policy.v1";
+export declare const SUBSCRIPTION_PRICE_POLICY_DEFAULT_DISCOUNT_BPS = 1000;
+export declare const SUBSCRIPTION_PRICE_POLICY_DEFAULT_QUANTUM_MINOR = 10;
+export interface SubscriptionPricePolicySemantics {
+    discountBps: number;
+    roundingQuantumMinor: number;
+    roundingRule: "FLOOR_TO_QUANTUM";
+}
+export interface SubscriptionPricePolicyCanonicalInput extends SubscriptionPricePolicySemantics {
+    id: string;
+    revisionNo: number;
+    priceListId: string;
+    regionCode: string;
+    currency: string;
+    channel: string;
+    effectiveFrom: string;
+    effectiveTo: string | null;
+}
+export interface SubscriptionPricePolicyRevision extends SubscriptionPricePolicyCanonicalInput {
+    digest: string;
+}
+export type SubscriptionPricePolicyDigestRefusal = "subscription_price_policy_digest_mismatch";

package/dist/pricing/contracts/policy.js

@@ -0,0 +1,3 @@
+export const SUBSCRIPTION_PRICE_POLICY_SCHEMA_VERSION = "subscription-price-policy.v1";
+export const SUBSCRIPTION_PRICE_POLICY_DEFAULT_DISCOUNT_BPS = 1_000;
+export const SUBSCRIPTION_PRICE_POLICY_DEFAULT_QUANTUM_MINOR = 10;

package/dist/pricing/contracts/provenance.d.ts

@@ -0,0 +1,24 @@
+export declare const CATALOG_FACTS_PROVENANCE_VERSION: "catalog_facts_v1";
+export declare const CATALOG_FACTS_POLICY_PROVENANCE_VERSION: "catalog_facts_v2";
+interface CatalogFactsFields {
+    skuId: string;
+    documentRevisionId: string;
+    documentDigest: string;
+    basePriceEntryId: string;
+    atTime: string;
+    currency: string;
+    resolvedUnitAmountMinor: number;
+    resolvedLineAmountMinor: number;
+    baseUnitAmountMinor: number;
+}
+export type CatalogFactsProvenance = CatalogFactsFields & ({
+    version: typeof CATALOG_FACTS_PROVENANCE_VERSION;
+    resolvedPriceEntryId: string;
+    mode: "one_time" | "subscription";
+} | {
+    version: typeof CATALOG_FACTS_POLICY_PROVENANCE_VERSION;
+    policyRevisionId: string;
+    policyDigest: string;
+    mode: "subscription";
+});
+export {};

package/dist/pricing/contracts/provenance.js

@@ -0,0 +1,2 @@
+export const CATALOG_FACTS_PROVENANCE_VERSION = "catalog_facts_v1";
+export const CATALOG_FACTS_POLICY_PROVENANCE_VERSION = "catalog_facts_v2";

package/dist/pricing/contracts/quote.d.ts

@@ -0,0 +1,94 @@
+import type { CommerceCurrency, CommerceMoney, CommerceTaxBreakdown } from "./money.js";
+import type { CommerceCodeRejectionDetail } from "./evidence.js";
+export declare const COMMERCE_CONTRACT_VERSION = "commerce.v0";
+export interface CommerceQuotePricingComponent {
+    scope: "line" | "order";
+    componentType: "base_unit" | "mode_discount" | "qty_tier" | "promo" | "loyalty" | "shipping" | "bundle";
+    amountMinor: number;
+    reasonCode: string;
+    reasonPayload: Record<string, unknown>;
+}
+/** Hosts may extend this context with their own validated policy. */
+export interface CommerceQuoteContext {
+    mode: "one_time" | "subscription";
+    cadenceDays?: number | null;
+    promoCodes: string[];
+}
+export interface CommerceQuoteLine {
+    sku: string;
+    productSlug: string;
+    quantity: number;
+    unitPriceGross: CommerceMoney;
+    lineSubtotalGross: CommerceMoney;
+    tax: CommerceTaxBreakdown;
+    pricingComponents?: CommerceQuotePricingComponent[];
+}
+export type CommercePromotionCustomerSemantic = "first_purchase_10" | "first_subscription_50" | "bundle_5";
+export interface CommerceQuoteDiscount {
+    promotionId: string;
+    code?: string | null;
+    label?: string;
+    appliesTo: "order_total" | "line" | "shipping";
+    amountOffMinor: number;
+    reasonCode: string;
+    /** Stable presentation identity for canonical offers; never inferred from an editable name. */
+    customerSemantic?: CommercePromotionCustomerSemantic;
+    promotionEngineVersion?: "promotion-engine.v2";
+    promotionCodeId?: string;
+    promotionCodeRevision?: number;
+    promotionDefinitionFingerprint?: string;
+    promotionCodeScopes?: Array<"one_time" | "subscription_initial">;
+    promotionMinimumReferenceMinor?: number;
+    promotionCodeValidTo?: string | null;
+    promotionBenefitKind?: "target_percentage" | "percentage" | "fixed_amount" | "free_shipping";
+    promotionBenefitValueBps?: number;
+    promotionBenefitValueMinor?: number;
+    floorApplied?: boolean;
+}
+/**
+ * Why a customer-submitted promo code did not produce a discount, surfaced so the FE
+ * can show a specific message instead of a generic "invalid". `better_price_exists` is
+ * the one non-error reason (eligible but unused because an automatic offer is equally
+ * good or better; the FE renders it neutrally); `scope_not_applicable` means the code
+ * is real but does not apply to this order type. The last two are v2-engine-only reasons.
+ */
+export type CommerceCodeRejectionReason = "not_recognized" | "already_used" | "not_eligible" | "expired" | "better_price_exists" | "scope_not_applicable";
+export interface CommerceCodeRejection {
+    code: string;
+    reason: CommerceCodeRejectionReason;
+}
+export interface CommerceQuote {
+    currency: CommerceCurrency;
+    taxIncluded: true;
+    lines: CommerceQuoteLine[];
+    discounts: CommerceQuoteDiscount[];
+    pricingComponents?: CommerceQuotePricingComponent[];
+    context?: CommerceQuoteContext;
+    /** Submitted coupon codes that produced no discount, with the reason. Omitted when empty. */
+    codeRejections?: CommerceCodeRejection[];
+    /** UI-safe specifics for selected rejected codes. Omitted when no detail is available. */
+    codeRejectionDetails?: CommerceCodeRejectionDetail[];
+    subtotalGross: CommerceMoney;
+    discountTotalGross: CommerceMoney;
+    /** Gross shipping before any free-shipping promo. Optional; absent ⇒ shipping not priced (legacy/0). */
+    shippingGross?: CommerceMoney;
+    /** Gross shipping discount from a free-shipping promo (≤ shippingGross). Optional; absent ⇒ 0. */
+    shippingDiscountGross?: CommerceMoney;
+    totalGross: CommerceMoney;
+    netTotal: CommerceMoney;
+    taxTotal: CommerceMoney;
+}
+export interface CreateQuoteRequest {
+    mode: "one_time" | "subscription";
+    lines: import("./money.js").CartLineInput[];
+    cadenceDays?: number | null;
+    promoCodes: string[];
+}
+export interface CreateQuoteResponse {
+    contractVersion: typeof COMMERCE_CONTRACT_VERSION;
+    quote: Omit<CommerceQuote, "lines"> & {
+        lines: Array<CommerceQuoteLine & {
+            catalogFacts?: import("./provenance.js").CatalogFactsProvenance;
+        }>;
+    };
+}

package/dist/pricing/contracts/quote.js

@@ -0,0 +1 @@
+export const COMMERCE_CONTRACT_VERSION = "commerce.v0";

package/dist/pricing/dbBackedCommerceQuoteHelpers.d.ts

@@ -0,0 +1,78 @@
+import type { CreateQuoteRequest } from "./contracts/quote.js";
+import type { CommerceMoney, CommerceQuotePricingComponent } from "./contracts/index.js";
+import type { PricingComponent } from "@openlup/core/pricing";
+import { type CommercePriceAuthorityPort } from "./ports.js";
+import type { PricingResolverPort, PricingMode, ResolvedPrice } from "@openlup/core/pricing";
+import type { CommerceQuoteCatalogItem } from "./commerceQuoteCatalogReadPort.js";
+/** Pure helpers for the DB-backed commerce quote port (extracted to keep the port under the LOC cap). */
+export interface SkuIndexEntry<Item = CommerceQuoteCatalogItem> {
+    item: Item;
+}
+export declare function buildSkuIndex<Item extends CommerceQuoteCatalogItem>(quoteCatalogReadPort: {
+    listQuoteCatalogItems(): Promise<Item[]>;
+}): Promise<Map<string, SkuIndexEntry<Item>>>;
+export declare function eligibleQtyForMode(request: CreateQuoteRequest, mode: Exclude<PricingMode, "any">): number;
+export declare function resolveOneTimeComparison(input: {
+    pricingResolverPort: PricingResolverPort;
+    variantId: string;
+    lineQty: number;
+    eligibleCartQty: number;
+    regionCode: string;
+    currency: string;
+    atTime: string;
+}): Promise<ResolvedPrice | null>;
+export interface StrictQuotePriceResolution {
+    base: ResolvedPrice;
+    resolved: ResolvedPrice;
+    policy?: {
+        policyRevisionId: string;
+        policyDigest: string;
+    };
+}
+/**
+ * Strict authority quotes require one exact one-time base anchor. Subscription money is either
+ * derived by a validated policy or taken from the authority's explicit legacy
+ * subscription observation; this layer never calls the generic resolver.
+ */
+export declare function resolveStrictQuotePrice(input: {
+    commercePriceAuthorityPort: CommercePriceAuthorityPort;
+    variantId: string;
+    mode: Exclude<PricingMode, "any">;
+    regionCode: string;
+    currency: string;
+    channel: string;
+    atTime: string;
+}): Promise<StrictQuotePriceResolution>;
+export declare function assertSubscriptionCheapest(input: {
+    requestSku: string;
+    modeAtLine: Exclude<PricingMode, "any">;
+    resolved: ResolvedPrice;
+    oneTime: ResolvedPrice | null;
+    vatRateBps: number;
+}): void;
+export declare function toGrossMinor(price: ResolvedPrice, vatRateBps: number): number;
+export declare function calculateIncludedVat(grossMinor: number, vatRateBps: number): {
+    netMinor: number;
+    vatMinor: number;
+};
+/**
+ * Map one kernel pricing component onto the quote transport shape.
+ *
+ * A component type outside the transport union stops the quote loudly. It is never
+ * cast through and never silently dropped: a dropped component breaks the breakdown
+ * invariant (components must sum to the line total), so a quote would go out priced
+ * from an incomplete explanation of its own total.
+ */
+export declare function mapPricingComponent(component: PricingComponent, scope: "line" | "order"): CommerceQuotePricingComponent;
+/**
+ * A money builder bound to one currency.
+ *
+ * This used to be a plain `money(amountMinor)` that stamped the settlement
+ * currency as a literal, which meant the quote's declared `currency` and the
+ * currency on every amount inside it came from two different places. They
+ * agreed only because the port's `currency` option was typed as that same
+ * literal. Binding the builder once per port makes the agreement structural:
+ * there is no second place left for the two to disagree.
+ */
+export declare function moneyIn(currency: string): (amountMinor: number) => CommerceMoney;
+export declare function sum(values: number[]): number;

package/dist/pricing/dbBackedCommerceQuoteHelpers.js

@@ -0,0 +1,146 @@
+import { CommerceQuoteError } from "./quotePorts.js";
+import { splitIncludedVat } from "./quoteSchemas.js";
+import { CommercePriceAuthorityError, } from "./ports.js";
+export async function buildSkuIndex(quoteCatalogReadPort) {
+    const items = await quoteCatalogReadPort.listQuoteCatalogItems();
+    return new Map(items.map((item) => [item.skuCode, { item }]));
+}
+export function eligibleQtyForMode(request, mode) {
+    return request.lines
+        .filter((line) => !line.isAddon)
+        .filter((line) => (line.modeAtLine ?? request.mode) === mode)
+        .reduce((sum, line) => sum + line.quantity, 0);
+}
+export async function resolveOneTimeComparison(input) {
+    return input.pricingResolverPort.resolvePrice({
+        variantId: input.variantId,
+        mode: "one_time",
+        lineQty: input.lineQty,
+        eligibleCartQty: input.eligibleCartQty,
+        regionCode: input.regionCode,
+        currency: input.currency,
+        atTime: input.atTime,
+    });
+}
+/**
+ * Strict authority quotes require one exact one-time base anchor. Subscription money is either
+ * derived by a validated policy or taken from the authority's explicit legacy
+ * subscription observation; this layer never calls the generic resolver.
+ */
+export async function resolveStrictQuotePrice(input) {
+    try {
+        const authority = await input.commercePriceAuthorityPort.resolvePrice({
+            variantId: input.variantId,
+            mode: input.mode,
+            regionCode: input.regionCode,
+            currency: input.currency,
+            channel: input.channel,
+            atTime: input.atTime,
+        });
+        return strictQuotePriceResolution(authority, input.mode);
+    }
+    catch (error) {
+        if (error instanceof CommercePriceAuthorityError) {
+            throw new CommerceQuoteError("PRICE_NOT_CONFIGURED", "Commerce price is not configured", { reason: error.code });
+        }
+        throw error;
+    }
+}
+function strictQuotePriceResolution(authority, requestedMode) {
+    const base = authority.base;
+    if (base.mode !== "one_time" || base.matchedMinQty !== 1) {
+        throw new CommerceQuoteError("PRICING_INVARIANT_VIOLATION", "Strict money authority did not return an exact one-time base anchor", { basePriceEntryId: base.priceEntryId, mode: base.mode, matchedMinQty: base.matchedMinQty });
+    }
+    if (requestedMode === "one_time") {
+        if (authority.kind !== "one_time" || authority.unitPriceMinor !== base.unitPriceMinor) {
+            throw new CommerceQuoteError("PRICING_INVARIANT_VIOLATION", "Strict money authority returned an invalid one-time result", { authorityKind: authority.kind, basePriceEntryId: base.priceEntryId });
+        }
+        return { base, resolved: base };
+    }
+    if (authority.kind === "subscription_policy") {
+        return {
+            base,
+            resolved: { ...base, mode: "subscription", unitPriceMinor: authority.unitPriceMinor },
+            policy: {
+                policyRevisionId: authority.policy.id,
+                policyDigest: authority.policy.digest,
+            },
+        };
+    }
+    if (authority.kind === "subscription_legacy") {
+        if (authority.legacyResolved.mode !== "subscription" || authority.legacyResolved.unitPriceMinor !== authority.unitPriceMinor) {
+            throw new CommerceQuoteError("PRICING_INVARIANT_VIOLATION", "Strict money authority returned an invalid legacy subscription result", { legacyPriceEntryId: authority.legacyResolved.priceEntryId, mode: authority.legacyResolved.mode });
+        }
+        return { base, resolved: authority.legacyResolved };
+    }
+    throw new CommerceQuoteError("PRICING_INVARIANT_VIOLATION", "Strict money authority returned a one-time result for a subscription quote", { authorityKind: authority.kind, basePriceEntryId: base.priceEntryId });
+}
+export function assertSubscriptionCheapest(input) {
+    if (input.modeAtLine === "subscription" &&
+        input.oneTime &&
+        toGrossMinor(input.resolved, input.vatRateBps) > toGrossMinor(input.oneTime, input.vatRateBps)) {
+        throw new CommerceQuoteError("PRICING_INVARIANT_VIOLATION", "Subscription price must not exceed active one-time price", {
+            sku: input.requestSku,
+            subscriptionPriceEntryId: input.resolved.priceEntryId,
+            oneTimePriceEntryId: input.oneTime.priceEntryId,
+        });
+    }
+}
+export function toGrossMinor(price, vatRateBps) {
+    if (price.amountKind === "gross")
+        return price.unitPriceMinor;
+    return Math.round((price.unitPriceMinor * (10_000 + vatRateBps)) / 10_000);
+}
+export function calculateIncludedVat(grossMinor, vatRateBps) {
+    return splitIncludedVat(grossMinor, vatRateBps);
+}
+/** Exhaustive transport vocabulary; widening requires the matching durable contract. */
+const TRANSPORT_COMPONENT_TYPES = {
+    base_unit: true,
+    mode_discount: true,
+    qty_tier: true,
+    promo: true,
+    loyalty: true,
+    shipping: true,
+    bundle: true,
+};
+function isTransportComponentType(componentType) {
+    return Object.prototype.hasOwnProperty.call(TRANSPORT_COMPONENT_TYPES, componentType);
+}
+/**
+ * Map one kernel pricing component onto the quote transport shape.
+ *
+ * A component type outside the transport union stops the quote loudly. It is never
+ * cast through and never silently dropped: a dropped component breaks the breakdown
+ * invariant (components must sum to the line total), so a quote would go out priced
+ * from an incomplete explanation of its own total.
+ */
+export function mapPricingComponent(component, scope) {
+    const componentType = component.component_type;
+    if (!isTransportComponentType(componentType)) {
+        throw new CommerceQuoteError("PRICING_INVARIANT_VIOLATION", "Pricing component type is not carried by the quote transport", { componentType, carriedTypes: Object.keys(TRANSPORT_COMPONENT_TYPES) });
+    }
+    return {
+        scope,
+        componentType,
+        amountMinor: component.amount_minor,
+        reasonCode: component.reason_code,
+        reasonPayload: component.reason_payload,
+    };
+}
+/**
+ * A money builder bound to one currency.
+ *
+ * This used to be a plain `money(amountMinor)` that stamped the settlement
+ * currency as a literal, which meant the quote's declared `currency` and the
+ * currency on every amount inside it came from two different places. They
+ * agreed only because the port's `currency` option was typed as that same
+ * literal. Binding the builder once per port makes the agreement structural:
+ * there is no second place left for the two to disagree.
+ */
+export function moneyIn(currency) {
+    return (amountMinor) => ({ amountMinor, currency });
+}
+export function sum(values) {
+    return values.reduce((total, value) => total + value, 0);
+}

package/dist/pricing/dbBackedCommerceQuotePort.d.ts

@@ -0,0 +1,74 @@
+import type { ShippingTerms } from "../shipping/index.js";
+import type { ResolvedAcquisitionTerms } from "./contracts/acquisitionTerms.js";
+import type { QuoteShippingPromotionInput, QuoteShippingPromotionResult } from "./quoteShippingPromotions.js";
+import type { PricingResolverPort } from "@openlup/core/pricing";
+import type { CreateQuoteResponse, PricingPolicySnapshot, CreateQuoteRequest, CommerceQuoteContext, CommerceQuoteLine, CommerceTaxProfile, CommerceQuoteDiscount, CommerceCodeRejection, CommerceCodeRejectionDetail, CartLineInput } from "./contracts/index.js";
+import { type CreateQuoteOptions } from "./quotePorts.js";
+import type { CommercePriceAuthorityPort } from "./ports.js";
+import type { CommerceQuoteCatalogItem } from "./commerceQuoteCatalogReadPort.js";
+export interface QuotePromotionResult {
+    discounts: CommerceQuoteDiscount[];
+    codeRejections: CommerceCodeRejection[];
+    codeRejectionDetails: CommerceCodeRejectionDetail[];
+}
+export interface DbBackedCommerceQuotePortDeps<Request extends CreateQuoteRequest, Item extends CommerceQuoteCatalogItem, LineContext extends object, Context extends CommerceQuoteContext> {
+    quoteCatalogReadPort: {
+        listQuoteCatalogItems(): Promise<Item[]>;
+    };
+    isStrictD1Quote: boolean;
+    commercePriceAuthorityPort?: CommercePriceAuthorityPort;
+    pricingResolverPort?: PricingResolverPort;
+    taxProfile: CommerceTaxProfile;
+    supportedTaxProfiles: readonly CommerceTaxProfile[];
+    regionCode: string;
+    currency: string;
+    now?: () => string;
+    shippingFlatMinor?: () => Promise<number>;
+    resolveQuoteShippingPromotions?: (input: QuoteShippingPromotionInput<Request>) => Promise<QuoteShippingPromotionResult>;
+    hasPromotionCodePort: boolean;
+    lineContext(line: CartLineInput, item: Item): LineContext;
+    quoteContext(request: Request, lines: Array<LineContext & {
+        line: CommerceQuoteLine;
+    }>): () => Context;
+    resolveAutomaticQuotePromotions(input: {
+        request: Request;
+        options?: CreateQuoteOptions;
+        regionCode: string;
+        referenceProductMinor: number;
+        subtotalGrossMinor: number;
+        shippingGrossMinor: number;
+        atTime: string;
+    }): Promise<Pick<QuotePromotionResult, "discounts" | "codeRejections">>;
+    applyPromotionCodesV2(input: {
+        preserveLegacyDiscountsWhenNoCandidates: boolean;
+        clientId: string | null;
+        mode: Request["mode"];
+        promoCodes: string[];
+        referenceProductMinor: number;
+        subtotalGrossMinor: number;
+        shippingGrossMinor: number;
+        discounts: CommerceQuoteDiscount[];
+        codeRejections: CommerceCodeRejection[];
+        atTime: string;
+    }): Promise<QuotePromotionResult>;
+}
+export declare function createDbBackedCommerceQuotePort<Request extends CreateQuoteRequest, Item extends CommerceQuoteCatalogItem, LineContext extends object, Context extends CommerceQuoteContext>(deps: DbBackedCommerceQuotePortDeps<Request, Item, LineContext, Context>): {
+    createQuote: (request: Request, options?: CreateQuoteOptions) => Promise<Omit<CreateQuoteResponse, "quote"> & {
+        quote: Omit<CreateQuoteResponse["quote"], "context"> & {
+            context: Context & {
+                pricingPolicy?: PricingPolicySnapshot;
+                shippingTerms?: ShippingTerms;
+                acquisitionTerms?: ResolvedAcquisitionTerms;
+            };
+        };
+    }>;
+    createServerAuthoritativeQuote: (request: Request, options?: CreateQuoteOptions) => Promise<Omit<CreateQuoteResponse, "quote"> & {
+        quote: Omit<CreateQuoteResponse["quote"], "context"> & {
+            context: Context & {
+                pricingPolicy?: PricingPolicySnapshot;
+                shippingTerms?: ShippingTerms;
+                acquisitionTerms?: ResolvedAcquisitionTerms;
+            };
+        };
+    }>;
+};