calculatePrice() -> 1230000

calculatePrice(inputSnapshot) -> PricingResult
  - price lines
  - charge breakdown
  - recurring totals
  - one-time totals
  - discount breakdown
  - promotion evaluation
  - override evidence
  - approval signals
  - rounding evidence
  - deterministic hash
  - explanation trace

total = basePrice - discount + tax;

same catalog version
same price list version
same product configuration
same customer context
same channel
same effective date
same promotion set
same override request
same rounding policy
=> same pricing result

Recurring total = 1,200,000 IDR
because:
  base internet plan = 1,000,000
  WiFi 6 router add-on = 150,000
  static IP add-on = 100,000
  bundle discount = -50,000

Promotion GAMING-2026 rejected
reason: incompatible_with_existing_discount
conflictsWith: CONTRACT-LOYALTY-15

Fiber Internet 1Gbps monthly price = 1,000,000 IDR / month
WiFi 6 Router monthly rental = 150,000 IDR / month
Express Installation fee = 300,000 IDR one-time

base recurring charge: 1,000,000
contract discount 10%: -100,000
manual override: -50,000
final recurring charge: 850,000

Promo: FIRST_3_MONTHS_50_PERCENT
Eligible if:
  - new customer
  - contract term >= 12 months
  - channel = ONLINE
  - product offering = FIBER_1G
Not stackable with:
  - loyalty discount
  - enterprise negotiated price

public record PricingRequest(
    String tenantId,
    String quoteId,
    String quoteRevision,
    String customerId,
    CustomerPricingContext customerContext,
    String channel,
    String market,
    LocalDate pricingDate,
    LocalDate requestedStartDate,
    List<PricingItemRequest> items,
    List<ManualPriceOverrideRequest> overrides,
    PricingPolicy policy
) {}

public record PricingItemRequest(
    String quoteItemId,
    String productOfferingId,
    String productOfferingVersion,
    String action,
    int quantity,
    ProductConfigurationSnapshot configuration,
    InstalledBaseSnapshot installedBaseSnapshot
) {}

public record CustomerPricingContext(
    String customerType,
    String segment,
    String riskClass,
    String contractAccountId,
    List<String> activeAgreementIds,
    List<String> eligibilityFlags
) {}

public record PricingPolicy(
    String currency,
    int moneyScale,
    RoundingMode roundingMode,
    DiscountStackingMode discountStackingMode,
    boolean requireExplanation,
    boolean allowManualOverride,
    boolean dryRun
) {}

public record PricingResult(
    String pricingRunId,
    String pricingHash,
    String currency,
    List<PriceLine> priceLines,
    List<QuoteTotal> totals,
    List<PromotionEvaluation> promotionEvaluations,
    List<ApprovalSignal> approvalSignals,
    List<PricingWarning> warnings,
    PricingExplanation explanation
) {}

public record PriceLine(
    String priceLineId,
    String quoteItemId,
    String productOfferingId,
    String chargeType,
    String chargeCode,
    String chargeName,
    Money baseAmount,
    int quantity,
    Money grossAmount,
    List<PriceAdjustment> adjustments,
    Money netAmount,
    String billingFrequency,
    LocalDate effectiveFrom,
    LocalDate effectiveTo,
    String sourcePriceId,
    String sourcePriceVersion
) {}

public record PriceAdjustment(
    String adjustmentType,
    String adjustmentCode,
    String sourceRuleId,
    String calculationMethod,
    Money amount,
    BigDecimal percent,
    String reason,
    boolean requiresApproval,
    int applicationOrder
) {}

public record QuoteTotal(
    String totalType,
    String billingFrequency,
    Money amount
) {}

ONE_TIME_TOTAL = 300,000 IDR
MONTHLY_RECURRING_TOTAL = 1,200,000 IDR
FIRST_MONTH_TOTAL = 1,500,000 IDR

double price = 1000000.00;

public record Money(String currency, BigDecimal amount) {

    public Money {
        if (currency == null || currency.isBlank()) {
            throw new IllegalArgumentException("currency is required");
        }
        if (amount == null) {
            throw new IllegalArgumentException("amount is required");
        }
    }

    public Money plus(Money other) {
        assertSameCurrency(other);
        return new Money(currency, amount.add(other.amount));
    }

    public Money minus(Money other) {
        assertSameCurrency(other);
        return new Money(currency, amount.subtract(other.amount));
    }

    public Money multiply(BigDecimal multiplier, int scale, RoundingMode roundingMode) {
        return new Money(currency, amount.multiply(multiplier).setScale(scale, roundingMode));
    }

    private void assertSameCurrency(Money other) {
        if (!currency.equals(other.currency)) {
            throw new IllegalArgumentException("currency mismatch: " + currency + " vs " + other.currency);
        }
    }
}

amount numeric(19, 4) not null,
currency char(3) not null

1. Normalize input
2. Resolve applicable price list
3. Resolve candidate prices
4. Evaluate price eligibility
5. Calculate base charge lines
6. Apply quantity rules
7. Apply bundle pricing
8. Evaluate promotions
9. Apply discounts and adjustments
10. Apply manual overrides
11. Evaluate approval signals
12. Round and totalize
13. Build explanation
14. Build deterministic hash

public final class PricingInputNormalizer {

    public NormalizedPricingRequest normalize(PricingRequest request) {
        requireNonBlank(request.tenantId(), "tenantId");
        requireNonBlank(request.customerId(), "customerId");
        requireNonBlank(request.channel(), "channel");
        requireNonNull(request.pricingDate(), "pricingDate");

        List<PricingItemRequest> items = request.items().stream()
            .sorted(Comparator.comparing(PricingItemRequest::quoteItemId))
            .toList();

        assertNoDuplicateItemId(items);

        return new NormalizedPricingRequest(
            request.tenantId(),
            request.quoteId(),
            request.quoteRevision(),
            request.customerId(),
            normalizeCustomerContext(request.customerContext()),
            normalizeChannel(request.channel()),
            normalizeMarket(request.market()),
            request.pricingDate(),
            request.requestedStartDate(),
            items,
            normalizeOverrides(request.overrides()),
            normalizePolicy(request.policy())
        );
    }
}

PRICE_LIST_ID: PL-ID-ENTERPRISE-2026
tenant: telco-id
market: ID
channel: DIRECT_SALES
customerSegment: ENTERPRISE
currency: IDR
validFrom: 2026-01-01
validTo: 2026-12-31

price list matches tenant
AND market matches
AND channel matches
AND customer segment matches or generic segment applies
AND pricing date within validity window
AND lifecycle state = ACTIVE

select price_list_id,
       version,
       currency,
       priority
from price_list
where tenant_id = #{tenantId}
  and market = #{market}
  and channel = #{channel}
  and valid_from <= #{pricingDate}
  and (valid_to is null or valid_to >= #{pricingDate})
  and lifecycle_state = 'ACTIVE'
order by priority desc, version desc
limit 1;

{
  "type": "https://api.example.com/problems/pricing/price-list-not-found",
  "title": "Applicable price list was not found",
  "status": 422,
  "code": "PRICE_LIST_NOT_FOUND",
  "detail": "No active price list found for market ID, channel DIRECT_SALES, segment ENTERPRISE, pricing date 2026-07-02."
}

FIBER_1G
  - monthly subscription: 1,000,000 IDR
  - installation fee: 300,000 IDR
  - activation fee: 100,000 IDR
  - early termination fee: formula-based

WiFi 6 Router
  - monthly rental: 150,000 IDR
Static IP Pack 5
  - monthly recurring: 100,000 IDR

select pop.product_offering_price_id,
       pop.product_offering_id,
       pop.version,
       pop.charge_code,
       pop.charge_type,
       pop.billing_frequency,
       pop.amount,
       pop.currency,
       pop.effective_from,
       pop.effective_to,
       pop.priority,
       pop.eligibility_rule_id
from product_offering_price pop
where pop.tenant_id = #{tenantId}
  and pop.price_list_id = #{priceListId}
  and pop.product_offering_id in
  <foreach item="id" collection="productOfferingIds" open="(" separator="," close=")">
    #{id}
  </foreach>
  and pop.effective_from <= #{pricingDate}
  and (pop.effective_to is null or pop.effective_to >= #{pricingDate})
  and pop.lifecycle_state = 'ACTIVE'
order by pop.product_offering_id,
         pop.charge_type,
         pop.priority desc,
         pop.version desc;

PRICE: ENTERPRISE_STATIC_IP_DISCOUNTED
Eligible if:
  customerSegment = ENTERPRISE
  selectedOption.staticIpCount >= 5
  contractTerm >= 12

public interface PriceEligibilityRule {
    EligibilityResult evaluate(PriceCandidate candidate, PricingEvaluationContext context);
}

public record EligibilityResult(
    boolean eligible,
    String reasonCode,
    String explanation
) {}

public final class PriceEligibilityRegistry {
    private final Map<String, PriceEligibilityRule> rules;

    public EligibilityResult evaluate(String ruleId, PriceCandidate candidate, PricingEvaluationContext context) {
        if (ruleId == null || ruleId.isBlank()) {
            return EligibilityResult.eligible("NO_RULE", "No eligibility rule configured.");
        }
        PriceEligibilityRule rule = rules.get(ruleId);
        if (rule == null) {
            return EligibilityResult.rejected("UNKNOWN_RULE", "Unknown eligibility rule: " + ruleId);
        }
        return rule.evaluate(candidate, context);
    }
}

public final class BaseChargeLineBuilder {

    public PriceLine build(PricingItemRequest item, PriceCandidate price, PricingPolicy policy) {
        Money base = new Money(price.currency(), price.amount());
        Money gross = base.multiply(BigDecimal.valueOf(item.quantity()), policy.moneyScale(), policy.roundingMode());

        return new PriceLine(
            ULID.next(),
            item.quoteItemId(),
            item.productOfferingId(),
            price.chargeType(),
            price.chargeCode(),
            price.chargeName(),
            base,
            item.quantity(),
            gross,
            List.of(),
            gross,
            price.billingFrequency(),
            price.effectiveFrom(),
            price.effectiveTo(),
            price.productOfferingPriceId(),
            price.version()
        );
    }
}

1 router included.
Additional router monthly rental = 100,000 each.
Minimum 5 static IP.
First 10 users included.
User 11+ = 50,000 per user per month.

public record QuantityPricingRule(
    String ruleId,
    String method,
    Integer includedQuantity,
    Integer minimumQuantity,
    Integer maximumQuantity,
    BigDecimal unitAmount
) {}

1-10 users: 50,000 each
11-50 users: 40,000 each
51+ users: 30,000 each

public interface QuantityCalculator {
    QuantityCalculationResult calculate(QuantityPricingRule rule, int quantity, Money unitPrice, PricingPolicy policy);
}

public enum BundlePricingMode {
    SUM_OF_COMPONENTS,
    BUNDLE_LEVEL_PRICE,
    COMPONENT_DISCOUNT,
    INCLUDED_COMPONENT,
    CONDITIONAL_BUNDLE_PRICE
}

Router monthly charge = 0
reason: included in bundle FIBER_1G_HOME_BUNDLE
sourceRule: BUNDLE_INCLUDED_ROUTER

DRAFT -> ACTIVE -> SUSPENDED -> EXPIRED -> RETIRED

validFrom <= pricingDate <= validTo

customerSegment = RESIDENTIAL
channel = ONLINE
productOffering = FIBER_1G
newCustomer = true
contractTerm >= 12

not stackable with LOYALTY_DISCOUNT
exclusive within promotion group INTERNET_ACQUISITION
max one promotion of type ACQUISITION

public record PromotionEvaluation(
    String promotionId,
    String promotionCode,
    boolean eligible,
    boolean applied,
    String rejectionReason,
    List<String> conflictPromotionIds,
    List<PriceAdjustment> generatedAdjustments
) {}

Promotion FIRST_3_MONTHS_50 rejected because channel DIRECT_SALES is not eligible; allowed channel ONLINE.

Base = 1,000,000
Discount A = 10%
Discount B = 10%

Parallel on base:
  final = 1,000,000 - 100,000 - 100,000 = 800,000

Sequential:
  after A = 900,000
  B = 10% of 900,000 = 90,000
  final = 810,000

public record DiscountApplicationContext(
    Money baseAmount,
    Money currentAmount,
    List<PriceAdjustment> existingAdjustments,
    DiscountStackingMode stackingMode
) {}

public final class DiscountApplicator {

    public PriceLine apply(PriceLine line, List<DiscountCandidate> discounts, PricingPolicy policy) {
        List<DiscountCandidate> selected = selectDiscounts(discounts, policy.discountStackingMode());
        Money current = line.netAmount();
        List<PriceAdjustment> adjustments = new ArrayList<>(line.adjustments());

        int order = adjustments.size() + 1;
        for (DiscountCandidate discount : selected) {
            Money amount = calculateDiscountAmount(line, current, discount, policy);
            adjustments.add(toAdjustment(discount, amount, order++));
            current = current.minus(amount);
        }

        return line.withAdjustmentsAndNetAmount(adjustments, current);
    }
}

net amount may be negative only if charge type = CREDIT or policy allows credit line

Sales sets price to 850,000.

public record ManualPriceOverrideRequest(
    String quoteItemId,
    String chargeCode,
    String overrideType,
    BigDecimal overrideAmount,
    BigDecimal overridePercent,
    String reasonCode,
    String requestedBy,
    String note
) {}

public record OverrideEvaluation(
    boolean accepted,
    boolean requiresApproval,
    String policyId,
    String reasonCode,
    Money beforeAmount,
    Money afterAmount,
    Money delta
) {}

Sales Rep may discount recurring charges up to 5% without approval.
Sales Manager may discount up to 15%.
Discount > 15% requires Finance Approval.
Discount > 25% rejected unless Deal Desk exception flag exists.

APPROVAL_REQUIRED: PRICE_OVERRIDE_ABOVE_LIMIT
APPROVAL_REQUIRED: MARGIN_BELOW_THRESHOLD
APPROVAL_REQUIRED: NON_STANDARD_PROMOTION_COMBINATION

public record ApprovalSignal(
    String signalType,
    String severity,
    String policyId,
    String quoteItemId,
    String priceLineId,
    String reason,
    Map<String, Object> evidence
) {}

public record RoundingPolicy(
    int calculationScale,
    int displayScale,
    RoundingMode calculationRoundingMode,
    RoundingMode displayRoundingMode
) {}

public final class QuoteTotalizer {

    public List<QuoteTotal> totalize(List<PriceLine> lines) {
        Map<TotalKey, Money> totals = new LinkedHashMap<>();

        for (PriceLine line : lines) {
            TotalKey key = new TotalKey(line.chargeType(), line.billingFrequency());
            totals.merge(key, line.netAmount(), Money::plus);
        }

        return totals.entrySet().stream()
            .map(e -> new QuoteTotal(e.getKey().totalType(), e.getKey().billingFrequency(), e.getValue()))
            .toList();
    }
}

Bad:
  total = 1,500,000

Good:
  oneTimeTotal = 300,000
  monthlyRecurringTotal = 1,200,000
  firstMonthDue = 1,500,000

public record PricingExplanation(
    List<PricingExplanationStep> steps
) {}

public record PricingExplanationStep(
    String stepCode,
    String targetType,
    String targetId,
    String message,
    Map<String, Object> evidence
) {}

{
  "stepCode": "PROMOTION_REJECTED",
  "targetType": "PROMOTION",
  "targetId": "PROMO_FIRST_3_MONTHS_50",
  "message": "Promotion rejected because channel DIRECT_SALES is not eligible.",
  "evidence": {
    "actualChannel": "DIRECT_SALES",
    "allowedChannels": ["ONLINE"]
  }
}

pricingHash = SHA-256(canonicalPricingInput + canonicalPricingPolicy + priceListVersion + catalogVersion)

public final class PricingHashBuilder {

    private final ObjectMapper canonicalMapper;

    public String hash(PricingHashInput input) {
        byte[] canonicalBytes = canonicalMapper.writeValueAsBytes(input);
        byte[] digest = MessageDigest.getInstance("SHA-256").digest(canonicalBytes);
        return HexFormat.of().formatHex(digest);
    }
}

pricing-domain/
  src/main/java/com/example/cpq/pricing/domain/
    Money.java
    PricingRequest.java
    PricingResult.java
    PriceLine.java
    PriceAdjustment.java
    QuoteTotal.java
    PromotionEvaluation.java
    ApprovalSignal.java
    PricingExplanation.java
    PricingEngine.java
    PricingPolicy.java
    DiscountStackingMode.java

pricing-application/
  src/main/java/com/example/cpq/pricing/application/
    PricingApplicationService.java
    PricingInputAssembler.java
    PriceListResolver.java
    PriceCandidateResolver.java
    PricingResultPersister.java

pricing-persistence-mybatis/
  src/main/java/com/example/cpq/pricing/persistence/
    PriceListMapper.java
    ProductOfferingPriceMapper.java
    PromotionMapper.java
    PricingSnapshotMapper.java
  src/main/resources/mybatis/pricing/
    PriceListMapper.xml
    ProductOfferingPriceMapper.xml
    PromotionMapper.xml
    PricingSnapshotMapper.xml

quote-application/
  src/main/java/com/example/cpq/quote/application/
    PriceQuoteCommandHandler.java

create table price_list (
    tenant_id varchar(64) not null,
    price_list_id varchar(64) not null,
    version varchar(32) not null,
    name varchar(255) not null,
    market varchar(64) not null,
    channel varchar(64) not null,
    customer_segment varchar(64),
    currency char(3) not null,
    priority integer not null default 0,
    lifecycle_state varchar(32) not null,
    valid_from date not null,
    valid_to date,
    created_at timestamptz not null,
    updated_at timestamptz not null,
    primary key (tenant_id, price_list_id, version)
);

create index idx_price_list_lookup
on price_list (tenant_id, market, channel, customer_segment, lifecycle_state, valid_from, valid_to, priority desc);

create table product_offering_price (
    tenant_id varchar(64) not null,
    product_offering_price_id varchar(64) not null,
    version varchar(32) not null,
    price_list_id varchar(64) not null,
    price_list_version varchar(32) not null,
    product_offering_id varchar(64) not null,
    product_offering_version varchar(32) not null,
    charge_code varchar(64) not null,
    charge_name varchar(255) not null,
    charge_type varchar(32) not null,
    billing_frequency varchar(32),
    amount numeric(19,4) not null,
    currency char(3) not null,
    priority integer not null default 0,
    eligibility_rule_id varchar(128),
    pricing_rule_config jsonb not null default '{}'::jsonb,
    lifecycle_state varchar(32) not null,
    effective_from date not null,
    effective_to date,
    created_at timestamptz not null,
    updated_at timestamptz not null,
    primary key (tenant_id, product_offering_price_id, version)
);

create index idx_pop_lookup
on product_offering_price (
    tenant_id,
    price_list_id,
    price_list_version,
    product_offering_id,
    lifecycle_state,
    effective_from,
    effective_to,
    priority desc
);

create table promotion (
    tenant_id varchar(64) not null,
    promotion_id varchar(64) not null,
    version varchar(32) not null,
    promotion_code varchar(128) not null,
    name varchar(255) not null,
    lifecycle_state varchar(32) not null,
    eligibility_rule_id varchar(128),
    adjustment_rule_config jsonb not null,
    stacking_group varchar(128),
    stackable boolean not null default false,
    priority integer not null default 0,
    valid_from date not null,
    valid_to date,
    created_at timestamptz not null,
    updated_at timestamptz not null,
    primary key (tenant_id, promotion_id, version)
);

create table quote_price_snapshot (
    tenant_id varchar(64) not null,
    quote_id varchar(64) not null,
    quote_revision integer not null,
    pricing_run_id varchar(64) not null,
    pricing_hash varchar(128) not null,
    price_list_id varchar(64) not null,
    price_list_version varchar(32) not null,
    currency char(3) not null,
    one_time_total numeric(19,4) not null default 0,
    monthly_recurring_total numeric(19,4) not null default 0,
    raw_result jsonb not null,
    created_at timestamptz not null,
    primary key (tenant_id, quote_id, quote_revision, pricing_run_id)
);

create index idx_quote_price_snapshot_latest
on quote_price_snapshot (tenant_id, quote_id, quote_revision, created_at desc);

create table quote_price_line (
    tenant_id varchar(64) not null,
    quote_id varchar(64) not null,
    quote_revision integer not null,
    pricing_run_id varchar(64) not null,
    price_line_id varchar(64) not null,
    quote_item_id varchar(64) not null,
    product_offering_id varchar(64) not null,
    charge_code varchar(64) not null,
    charge_type varchar(32) not null,
    billing_frequency varchar(32),
    base_amount numeric(19,4) not null,
    quantity integer not null,
    gross_amount numeric(19,4) not null,
    net_amount numeric(19,4) not null,
    currency char(3) not null,
    source_price_id varchar(64) not null,
    source_price_version varchar(32) not null,
    adjustments jsonb not null default '[]'::jsonb,
    explanation jsonb not null default '{}'::jsonb,
    created_at timestamptz not null,
    primary key (tenant_id, quote_id, quote_revision, pricing_run_id, price_line_id)
);

public interface PriceListMapper {
    PriceListRow findApplicablePriceList(FindApplicablePriceListQuery query);
}

<select id="findApplicablePriceList" resultMap="PriceListRowMap">
  select tenant_id,
         price_list_id,
         version,
         market,
         channel,
         customer_segment,
         currency,
         priority,
         lifecycle_state,
         valid_from,
         valid_to
  from price_list
  where tenant_id = #{tenantId}
    and market = #{market}
    and channel = #{channel}
    and lifecycle_state = 'ACTIVE'
    and valid_from &lt;= #{pricingDate}
    and (valid_to is null or valid_to &gt;= #{pricingDate})
    and (
      customer_segment = #{customerSegment}
      or customer_segment is null
    )
  order by
    case when customer_segment = #{customerSegment} then 1 else 0 end desc,
    priority desc,
    version desc
  limit 1
</select>

public interface ProductOfferingPriceMapper {
    List<ProductOfferingPriceRow> findCandidatePrices(FindCandidatePricesQuery query);
}

public interface PricingSnapshotMapper {
    void insertSnapshot(QuotePriceSnapshotRow row);
    void batchInsertPriceLines(@Param("rows") List<QuotePriceLineRow> rows);
}

public record PriceQuoteCommand(
    String tenantId,
    String quoteId,
    int expectedVersion,
    String idempotencyKey,
    String requestedBy
) {}

public final class PriceQuoteCommandHandler {

    private final UnitOfWork unitOfWork;
    private final QuoteRepository quoteRepository;
    private final PricingInputAssembler pricingInputAssembler;
    private final PricingEngine pricingEngine;
    private final PricingSnapshotRepository pricingSnapshotRepository;
    private final OutboxRepository outboxRepository;
    private final IdempotencyService idempotencyService;

    public PriceQuoteResult handle(PriceQuoteCommand command) {
        return idempotencyService.execute(command.idempotencyKey(), command, () ->
            unitOfWork.required(() -> {
                Quote quote = quoteRepository.loadForUpdate(command.tenantId(), command.quoteId());
                quote.assertVersion(command.expectedVersion());
                quote.assertCanBePriced();

                PricingRequest request = pricingInputAssembler.assemble(quote);
                PricingResult result = pricingEngine.calculate(request);

                quote.applyPricing(result, command.requestedBy());
                quoteRepository.save(quote);
                pricingSnapshotRepository.insert(quote, result);

                outboxRepository.insert(OutboxEvent.quotePriced(quote, result));

                return PriceQuoteResult.from(quote, result);
            })
        );
    }
}

quote update + price snapshot + outbox event must commit atomically.

POST /api/v1/quotes/{quoteId}/commands/price
Idempotency-Key: 01J...
If-Match: "quote-version-7"
Content-Type: application/json

{
  "requestedBy": "user-123",
  "dryRun": false
}

{
  "quoteId": "Q-10001",
  "quoteVersion": 8,
  "pricingRunId": "PR-90001",
  "pricingHash": "sha256:...",
  "status": "PRICED",
  "totals": [
    {
      "totalType": "ONE_TIME_TOTAL",
      "amount": "300000.0000",
      "currency": "IDR"
    },
    {
      "totalType": "MONTHLY_RECURRING_TOTAL",
      "amount": "1200000.0000",
      "currency": "IDR"
    }
  ],
  "approvalSignals": []
}

price-list:{tenant}:{market}:{channel}:{segment}:{date} -> priceListId/version
prices:{tenant}:{priceListId}:{version}:{offeringIdsHash}:{date} -> candidate price list
promotions:{tenant}:{market}:{channel}:{date} -> active promotion metadata

PriceListPublished -> invalidate price-list and prices keys
PromotionPublished -> invalidate promotion keys
CatalogPublished -> invalidate price dependencies

If cache is unavailable, pricing must still work from PostgreSQL, possibly slower.

QuotePriced
QuotePricingFailed
QuoteApprovalRequired
PriceOverrideRequested

{
  "eventType": "QuotePriced",
  "eventVersion": "1.0",
  "tenantId": "telco-id",
  "quoteId": "Q-10001",
  "quoteRevision": 3,
  "pricingRunId": "PR-90001",
  "pricingHash": "sha256:...",
  "totals": [
    {
      "totalType": "MONTHLY_RECURRING_TOTAL",
      "amount": "1200000.0000",
      "currency": "IDR"
    }
  ],
  "approvalRequired": false,
  "occurredAt": "2026-07-02T10:00:00Z"
}

scenario-001-base-fiber-1g-no-discount
scenario-002-fiber-1g-with-router-and-static-ip
scenario-003-promotion-rejected-by-channel
scenario-004-manual-override-soft-limit-approval-required
scenario-005-manual-override-hard-limit-rejected
scenario-006-bundle-included-router
scenario-007-tiered-user-pricing
scenario-008-currency-mismatch-rejected
scenario-009-reprice-same-input-same-hash
scenario-010-reprice-different-price-list-different-hash

No duplicate price line ID.
Net amount = gross amount - sum(adjustments) for standard charge.
Totals equal sum of price lines grouped by type/frequency.
Same canonical input produces same hash.
Unknown rule never applies silently.
Currency mismatch never produces total.

Small quote: 1-5 items, < 200 ms server-side pricing
Medium quote: 10-50 items, < 1 s server-side pricing
Large enterprise quote: 100+ items, async pricing accepted

Small quote -> sync pricing response
Large quote -> command accepted, PricingRequested event, async job, polling/read projection

Milestone 1:
  Money model
  Price list lookup
  Product offering price candidate lookup
  Base price lines
  Totals

Milestone 2:
  Quantity rules
  Bundle inclusion
  Simple discounts
  Price snapshot persistence

Milestone 3:
  Promotion evaluation
  Discount stacking
  Rejected promotion explanation

Milestone 4:
  Manual override
  Approval signal
  Audit evidence

Milestone 5:
  Pricing hash
  Idempotent price quote command
  Outbox event

Milestone 6:
  Redis candidate cache
  Performance tests
  Large quote async path

create quote
add item
configure item
price quote
submit quote
approval pending
approve/reject
accept quote
expire quote
revise quote
cancel quote