@dainamite/cpq 0.5.0 → 0.7.0

package/src/modules/cpq/components/__tests__/PriceWaterfall.test.tsx

@@ -0,0 +1,38 @@
+import * as React from 'react'
+import { renderToStaticMarkup } from 'react-dom/server'
+import { I18nProvider } from '@open-mercato/shared/lib/i18n/context'
+import { DepthBadge, PriceWaterfall } from '../PriceWaterfall'
+
+const withI18n = (node: React.ReactNode) => <I18nProvider locale="en" dict={{}}>{node}</I18nProvider>
+
+const text = (html: string) => html.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim()
+
+it('renders list, rule, standard, negotiated and offer steps with the reason label', () => {
+  const html = renderToStaticMarkup(withI18n(
+    <PriceWaterfall
+      currency="USD"
+      reasonLabels={{ competitive_match: 'Competitive match' }}
+      charge={{
+        chargeType: 'mrc', unitPrice: 80, totalPrice: 80, listUnitPrice: 100, standardUnitPrice: 90,
+        adjustments: [
+          { origin: 'rule', ruleCode: 'VOL', ruleName: 'Volume', ruleType: 'discount_percent', value: 10, unitPriceBefore: 100, unitPriceAfter: 90, delta: -10 },
+          { origin: 'manual', adjustmentId: 'a1', ruleCode: 'a1', ruleName: 'competitive_match', ruleType: 'price_override', value: 80, unitPriceBefore: 90, unitPriceAfter: 80, delta: -10, reasonCode: 'competitive_match' },
+        ],
+      }}
+      renderManualActions={(id) => <button>edit {id}</button>}
+    />,
+  ))
+  const content = text(html)
+  expect(content).toMatch(/List price \$100\.00/)
+  expect(content).toMatch(/Price rule: Volume 10%/)
+  expect(content).toMatch(/Standard price \$90\.00/)
+  expect(content).toMatch(/Negotiated: Competitive match \$80\.00/)
+  expect(content).toMatch(/Offer price \$80\.00/)
+  expect(content).toContain('edit a1')
+  expect(content.match(/edit/g)).toHaveLength(1)
+})
+
+it('renders a signed depth badge only when prices differ', () => {
+  expect(text(renderToStaticMarkup(<DepthBadge before={100} after={80} />))).toBe('−20%')
+  expect(renderToStaticMarkup(<DepthBadge before={100} after={100} />)).toBe('')
+})

package/src/modules/cpq/components/useCpqRowActions.tsx

@@ -11,10 +11,14 @@ export type UseCpqRowActionsOptions<T extends { id: string }> = {
   /** DELETE endpoint that accepts `{ id }` body (e.g. `/api/cpq/product-offerings`). */
   endpoint: string
   /**
-   * Singular noun for the entity, used in confirm + flash messages.
-   * E.g. `'offering'`, `'pricing table'`, `'price rule'`.
+   * Singular noun for the entity (e.g. `'offering'`).
+   *
+   * @deprecated Not used in messages any more: splicing a noun into a
+   * sentence cannot produce correct grammar in ES / DE / PL (gender, case).
+   * Confirm and flash messages are noun-free and count-based
+   * (spec 2026-11-15-cpq-multi-language). Kept for API compatibility.
    */
-  entityName: string
+  entityName?: string
   /**
    * Build the href for the row's edit/detail page (e.g. `(row) =>
    * `/backend/cpq/offerings/${row.id}`).
@@ -59,7 +63,7 @@ export type CpqRowActionsApi<T extends { id: string }> = {
 export function useCpqRowActions<T extends { id: string }>(
   options: UseCpqRowActionsOptions<T>,
 ): CpqRowActionsApi<T> {
-  const { endpoint, entityName, editHref, onReload, canDelete } = options
+  const { endpoint, editHref, onReload, canDelete } = options
   const t = useT()
   const { confirm, ConfirmDialogElement } = useConfirmDialog()
 
@@ -79,25 +83,22 @@ export function useCpqRowActions<T extends { id: string }>(
     async (row: T) => {
       if (canDelete && !canDelete(row)) return
       const confirmed = await confirm({
-        title: t(
-          'cpq.rowActions.deleteOne.confirm',
-          `Delete this ${entityName}?`,
-        ),
+        title: t('cpq.rowActions.deleteOne.confirm', 'Delete this item?'),
         variant: 'destructive',
       })
       if (!confirmed) return
       const ok = await deleteOne(row.id)
       if (!ok) {
         flash(
-          t('cpq.rowActions.deleteOne.error', `Failed to delete ${entityName}`),
+          t('cpq.rowActions.deleteOne.error', 'Failed to delete the item'),
           'error',
         )
         return
       }
-      flash(t('cpq.rowActions.deleteOne.success', `${entityName} deleted`), 'success')
+      flash(t('cpq.rowActions.deleteOne.success', 'Item deleted'), 'success')
       onReload()
     },
-    [canDelete, confirm, deleteOne, entityName, onReload, t],
+    [canDelete, confirm, deleteOne, onReload, t],
   )
 
   const bulkDelete = React.useCallback(
@@ -106,19 +107,13 @@ export function useCpqRowActions<T extends { id: string }>(
       const eligible = canDelete ? rows.filter(canDelete) : rows
       if (!eligible.length) {
         flash(
-          t(
-            'cpq.rowActions.deleteBulk.noEligible',
-            `None of the selected ${entityName}s can be deleted in their current state.`,
-          ),
+          t('cpq.rowActions.deleteBulk.noEligible', 'None of the selected items can be deleted in their current state.'),
           'error',
         )
         return { ok: false }
       }
       const confirmed = await confirm({
-        title: t(
-          'cpq.rowActions.deleteBulk.confirm',
-          `Delete ${eligible.length} ${entityName}${eligible.length > 1 ? 's' : ''}?`,
-        ),
+        title: t('cpq.rowActions.deleteBulk.confirm', 'Delete selected items ({count})?', { count: eligible.length }),
         variant: 'destructive',
       })
       if (!confirmed) return { ok: false }
@@ -131,22 +126,19 @@ export function useCpqRowActions<T extends { id: string }>(
 
       if (failed > 0) {
         flash(
-          t(
-            'cpq.rowActions.deleteBulk.partialError',
-            `Failed to delete ${failed} ${entityName}${failed > 1 ? 's' : ''}`,
-          ),
+          t('cpq.rowActions.deleteBulk.partialError', 'Failed to delete {count} of the selected items', { count: failed }),
           'error',
         )
       } else {
         flash(
-          t('cpq.rowActions.deleteBulk.success', `${entityName}s deleted`),
+          t('cpq.rowActions.deleteBulk.success', 'Selected items deleted ({count})', { count: eligible.length }),
           'success',
         )
       }
       onReload()
       return { ok: failed === 0, affectedCount: eligible.length - failed }
     },
-    [canDelete, confirm, deleteOne, entityName, onReload, t],
+    [canDelete, confirm, deleteOne, onReload, t],
   )
 
   const buildItems = React.useCallback(

package/src/modules/cpq/components/useGrantedFeatures.ts

@@ -0,0 +1,35 @@
+'use client'
+
+import * as React from 'react'
+import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
+
+type FeatureCheckResponse = { granted: string[] }
+
+/**
+ * Resolve which of `features` the current user holds, through the framework's
+ * `POST /api/auth/feature-check` endpoint (the same one the component-override
+ * provider uses). Returns an empty list until the check completes, so callers
+ * hide privileged actions by default.
+ */
+export function useGrantedFeatures(features: readonly string[]): readonly string[] {
+  const [granted, setGranted] = React.useState<readonly string[]>([])
+  const key = features.join('|')
+
+  React.useEffect(() => {
+    if (!key) return
+    let cancelled = false
+    void (async () => {
+      const call = await apiCall<FeatureCheckResponse>('/api/auth/feature-check', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ features: key.split('|') }),
+      })
+      if (!cancelled && call.ok && call.result?.granted) setGranted(call.result.granted)
+    })()
+    return () => {
+      cancelled = true
+    }
+  }, [key])
+
+  return granted
+}

package/src/modules/cpq/data/__tests__/price-adjustment-migration.test.ts

@@ -0,0 +1,11 @@
+import { Migration20261110213052 } from '../../migrations/Migration20261110213052'
+
+it('generates a rollback that removes the new table before it can be recreated', () => {
+  const up: string[] = [], down: string[] = []
+  Migration20261110213052.prototype.up.call({ addSql: (sql: string) => up.push(sql) } as never)
+  Migration20261110213052.prototype.down.call({ addSql: (sql: string) => down.push(sql) } as never)
+  expect(up.join('\n')).toContain('create table "cpq_quote_price_adjustments"')
+  expect(down.join('\n')).toContain('drop table if exists "cpq_quote_price_adjustments"')
+  expect(up.join('\n')).toContain('add "pricing_revision"')
+  expect(down.join('\n')).toContain('drop column "pricing_revision"')
+})

package/src/modules/cpq/data/__tests__/price-adjustments.test.ts

@@ -0,0 +1,26 @@
+import { cpqPriceAdjustmentInputSchema, cpqPriceAdjustmentPatchSchema } from '../price-adjustments'
+const valid = {
+  level: 'charge', quoteLineId: '11111111-1111-4111-8111-111111111111', chargeCode: 'setup',
+  adjustmentType: 'price_override', value: 80, currencyCode: 'USD', reasonCode: 'competitive_match',
+}
+it('allows a zero override and percentage discounts with no currency', () => {
+  expect(cpqPriceAdjustmentInputSchema.parse({ ...valid, value: 0 }).value).toBe(0)
+  expect(cpqPriceAdjustmentInputSchema.parse({ ...valid, adjustmentType: 'discount_percent', value: 100, currencyCode: undefined }).value).toBe(100)
+})
+it.each([
+  { level: 'quote' }, { quoteLineId: 'bad' }, { chargeCode: null }, { value: -1 }, { value: Infinity }, { value: 1.23456 }, { value: 100_000_000_000_000 },
+  { adjustmentType: 'discount_percent', value: 101 }, { adjustmentType: 'discount_percent', value: 0 },
+  { adjustmentType: 'discount_absolute', value: 0 }, { currencyCode: null }, { currencyCode: 'usd' },
+  { reasonCode: 'other', reasonNote: '' }, { reasonNote: 'x'.repeat(501) },
+  { fromMonth: 2 }, { toMonth: 3 }, { windowKind: 'absolute' },
+  { level: 'line', chargeCode: undefined, adjustmentType: 'price_override' }, { chargeTypeFilter: 'mrc' },
+])('rejects malformed or unsupported adjustments: %j', (patch) => {
+  expect(cpqPriceAdjustmentInputSchema.safeParse({ ...valid, ...patch }).success).toBe(false)
+})
+it('accepts filtered line percentages and an explanation for other', () => {
+  expect(cpqPriceAdjustmentInputSchema.safeParse({ ...valid, level: 'line', chargeCode: undefined, chargeTypeFilter: 'mrc', adjustmentType: 'discount_percent', value: 20, reasonCode: 'other', reasonNote: 'One-time negotiation' }).success).toBe(true)
+})
+it('never accepts target changes through PATCH; merged patches are validated by the full schema', () => {
+  expect(cpqPriceAdjustmentPatchSchema.safeParse({ quoteLineId: valid.quoteLineId }).success).toBe(false)
+  expect(cpqPriceAdjustmentPatchSchema.parse({ reasonNote: 'New note' })).toEqual({ reasonNote: 'New note' })
+})

package/src/modules/cpq/data/entities.ts

@@ -631,6 +631,7 @@ export class CpqPriceRule {
 export class CpqQuoteConfiguration {
   [OptionalProps]?:
     | 'cpqStatus'
+    | 'pricingRevision'
     | 'version'
     | 'currencyCode'
     | 'quoteType'
@@ -653,6 +654,9 @@ export class CpqQuoteConfiguration {
   @Property({ name: 'customer_id', type: 'uuid' })
   customerId!: string
 
+  @Property({ name: 'pricing_revision', type: 'integer', default: 0 })
+  pricingRevision: number = 0
+
   @Property({ name: 'cpq_status', type: 'text', default: 'new' })
   cpqStatus: string = 'new'
 
@@ -1475,3 +1479,82 @@ export class CpqSubscriptionChangeLog {
   @Property({ name: 'deleted_at', type: Date, nullable: true })
   deletedAt?: Date | null
 }
+
+
+// ─── Deal-specific adjustments, separate from catalog price rules ───
+@Entity({ tableName: 'cpq_quote_price_adjustments' })
+@Index({ name: 'cpq_qpa_quote_config_idx', properties: ['organizationId', 'tenantId', 'quoteConfigurationId'] })
+@Index({ name: 'cpq_qpa_quote_line_idx', properties: ['organizationId', 'tenantId', 'quoteLineId'] })
+@Index({ name: 'cpq_qpa_quote_idx', properties: ['organizationId', 'tenantId', 'quoteId'] })
+export class CpqQuotePriceAdjustment {
+  [OptionalProps]?: 'windowKind' | 'fromMonth' | 'toMonth' | 'isActive' | 'createdAt' | 'updatedAt' | 'deletedAt'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'organization_id', type: 'uuid' })
+  organizationId!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'quote_configuration_id', type: 'uuid' })
+  quoteConfigurationId!: string
+
+  @Property({ name: 'quote_id', type: 'uuid' })
+  quoteId!: string
+
+  @Property({ name: 'quote_line_id', type: 'uuid' })
+  quoteLineId!: string
+
+  @Property({ type: 'text' })
+  level!: 'charge' | 'line'
+
+  @Property({ name: 'charge_code', type: 'text', nullable: true })
+  chargeCode: string | null = null
+
+  @Property({ name: 'charge_type_filter', type: 'text', nullable: true })
+  chargeTypeFilter: 'nrc' | 'mrc' | null = null
+
+  @Property({ name: 'adjustment_type', type: 'text' })
+  adjustmentType!: 'discount_percent' | 'discount_absolute' | 'price_override'
+
+  @Property({ type: 'numeric', columnType: 'numeric(18, 4)' })
+  value!: string
+
+  @Property({ name: 'currency_code', type: 'text', nullable: true })
+  currencyCode: string | null = null
+
+  @Property({ name: 'window_kind', type: 'text', default: 'relative' })
+  windowKind: string = 'relative'
+
+  @Property({ name: 'from_month', type: 'integer', default: 1 })
+  fromMonth: number = 1
+
+  @Property({ name: 'to_month', type: 'integer', nullable: true })
+  toMonth: number | null = null
+
+  @Property({ name: 'reason_code', type: 'text' })
+  reasonCode!: string
+
+  @Property({ name: 'reason_note', type: 'text', nullable: true })
+  reasonNote: string | null = null
+
+  @Property({ name: 'created_by_user_id', type: 'uuid' })
+  createdByUserId!: string
+
+  @Property({ name: 'updated_by_user_id', type: 'uuid', nullable: true })
+  updatedByUserId: string | null = null
+
+  @Property({ name: 'is_active', type: 'boolean', default: true })
+  isActive: boolean = true
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+
+  @Property({ name: 'updated_at', type: Date, onUpdate: () => new Date() })
+  updatedAt: Date = new Date()
+
+  @Property({ name: 'deleted_at', type: Date, nullable: true })
+  deletedAt: Date | null = null
+}

package/src/modules/cpq/data/price-adjustments.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod'
+
+export const adjustmentTypeSchema = z.enum(['discount_percent', 'discount_absolute', 'price_override'])
+const adjustmentFields = {
+  adjustmentType: adjustmentTypeSchema,
+  // Match numeric(18,4), so saving never silently rounds the previewed input.
+  value: z.number().finite().min(0).max(99_999_999_999_999).multipleOf(0.0001),
+  currencyCode: z.string().regex(/^[A-Z]{3}$/).nullish(),
+  chargeTypeFilter: z.enum(['nrc', 'mrc']).nullish(),
+  reasonCode: z.string().trim().min(1).max(100),
+  reasonNote: z.string().trim().max(500).nullish(),
+  expectedRevision: z.number().int().min(0).optional(),
+}
+export const cpqPriceAdjustmentInputSchema = z.object({
+  ...adjustmentFields,
+  level: z.enum(['charge', 'line']),
+  quoteLineId: z.string().uuid(),
+  chargeCode: z.string().trim().min(1).max(255).nullish(),
+  windowKind: z.literal('relative').optional(),
+  fromMonth: z.literal(1).optional(),
+  toMonth: z.null().optional(),
+}).strict().superRefine((input, ctx) => {
+  const error = (path: string, message: string) => ctx.addIssue({ code: 'custom', path: [path], message })
+  if (input.level === 'charge' && !input.chargeCode) error('chargeCode', 'TARGET_NOT_FOUND')
+  if (input.level === 'charge' && input.chargeTypeFilter) error('chargeTypeFilter', 'TYPE_NOT_ALLOWED')
+  if (input.level === 'line' && input.chargeCode) error('chargeCode', 'TYPE_NOT_ALLOWED')
+  if (input.level === 'line' && input.adjustmentType !== 'discount_percent') error('adjustmentType', 'TYPE_NOT_ALLOWED')
+  if (input.adjustmentType === 'discount_percent' && (input.value <= 0 || input.value > 100)) error('value', 'INVALID_PERCENT')
+  if (input.adjustmentType === 'discount_absolute' && input.value <= 0) error('value', 'INVALID_AMOUNT')
+  if (input.adjustmentType !== 'discount_percent' && !input.currencyCode) error('currencyCode', 'CURRENCY_REQUIRED')
+  if (input.reasonCode === 'other' && !input.reasonNote) error('reasonNote', 'REASON_NOTE_REQUIRED')
+})
+export const cpqPriceAdjustmentPatchSchema = z.object(adjustmentFields).partial().strict()
+export type PriceAdjustmentInput = z.infer<typeof cpqPriceAdjustmentInputSchema>
+export type PriceAdjustmentPatch = z.infer<typeof cpqPriceAdjustmentPatchSchema>
+
+/** Pure pricing representation; persistence metadata stays outside the resolver. */
+export const resolvedPriceAdjustmentSchema = z.object({
+  ...cpqPriceAdjustmentInputSchema.shape,
+  id: z.string().uuid(),
+  createdByUserId: z.string().uuid().optional(),
+})
+export type PriceAdjustment = z.infer<typeof resolvedPriceAdjustmentSchema>
+export const adjustmentErrorSchema = z.object({
+  adjustmentId: z.string(),
+  quoteLineId: z.string(),
+  chargeCode: z.string().optional(),
+  code: z.enum(['ADJUSTMENT_TARGET_MISSING', 'TARGET_AMBIGUOUS', 'ABOVE_STANDARD', 'CURRENCY_MISMATCH', 'TYPE_NOT_ALLOWED', 'LINE_NOT_ELIGIBLE', 'ADJUSTMENT_OVERLAP']),
+})
+export type AdjustmentError = z.infer<typeof adjustmentErrorSchema>
+
+export const cpqPriceAdjustmentPreviewSchema = z.object({
+  draft: cpqPriceAdjustmentInputSchema,
+  replaceAdjustmentId: z.string().uuid().optional(),
+}).strict()
+
+export const ADJUSTMENT_TOGGLE = 'cpq.manual_price_adjustments'
+export const REASON_DICTIONARY = 'cpq.price_adjustment_reason'
+export const DEFAULT_ADJUSTMENT_REASONS = [
+  { value: 'competitive_match', label: 'Competitive match' },
+  { value: 'volume_commitment', label: 'Volume commitment' },
+  { value: 'loyalty', label: 'Loyalty' },
+  { value: 'promotion', label: 'Promotion' },
+  { value: 'strategic_deal', label: 'Strategic deal' },
+  { value: 'price_correction', label: 'Price correction' },
+  { value: 'other', label: 'Other' },
+] as const

package/src/modules/cpq/data/validators.ts

@@ -378,6 +378,7 @@ const cpqPricePreviewItemSchema = z.object({
 )
 
 export const cpqPricePreviewSchema = z.object({
+  includeWaterfall: z.boolean().optional().default(false),
   primaryItem: cpqPricePreviewItemSchema.nullish(),
   childItems: z.array(cpqPricePreviewItemSchema),
   currencyCode: z.string().min(1).optional(),
@@ -691,3 +692,5 @@ export const cpqConvertQuoteToOrderSchema = z.object({
 export const cpqOrderStatusTransitionSchema = z.object({
   targetStatus: z.string().min(1),
 })
+
+export { cpqPriceAdjustmentInputSchema, cpqPriceAdjustmentPatchSchema } from './price-adjustments'

package/src/modules/cpq/di.ts

@@ -9,6 +9,7 @@ import { DefaultCpqQuotingService } from './services/cpqQuotingService'
 import { DefaultCpqWizardService } from './services/cpqWizardService'
 import { DefaultCpqInventoryService } from './services/cpqInventoryService'
 import { DefaultCpqOrderService } from './services/cpqOrderService'
+import { CpqAdjustmentService } from './services/priceAdjustments/adjustmentService'
 import { DefaultCpqBundleService } from './services/cpqBundleService'
 
 /**
@@ -20,6 +21,11 @@ import { DefaultCpqBundleService } from './services/cpqBundleService'
  */
 export function register(container: AppContainer) {
   container.register({
+    cpqAdjustmentService: asFunction(() => new CpqAdjustmentService({
+      em: container.resolve('em'),
+      quotingService: container.resolve('cpqQuotingService'),
+      featureTogglesService: container.resolve('featureTogglesService'),
+    })).scoped(),
     cpqPricingService: asFunction(({ em }: { em: EntityManager }) => {
       return new DefaultCpqPricingService(em)
     }).scoped().proxy(),

package/src/modules/cpq/events.ts

@@ -1,4 +1,26 @@
 import { createModuleEvents } from '@open-mercato/shared/modules/events'
+import type { EventPayloadSchemaField } from '@open-mercato/shared/modules/events'
+
+/** Fields shared by both quote pricing signals (see `quotePricingEvents.ts`). */
+const quotePricingSnapshotFields: EventPayloadSchemaField[] = [
+  { path: 'tenantId', type: 'text' },
+  { path: 'organizationId', type: 'text' },
+  { path: 'quoteId', type: 'text', label: 'CPQ quote id' },
+  { path: 'quoteType', type: 'select', label: 'Quote type' },
+  { path: 'cpqStatus', type: 'text', label: 'Status' },
+  { path: 'currencyCode', type: 'text' },
+  { path: 'pricingRevision', type: 'number' },
+  { path: 'snapshotHash', type: 'text' },
+  { path: 'dealValue.list', type: 'number', label: 'Deal value (list)' },
+  { path: 'dealValue.standard', type: 'number', label: 'Deal value (standard)' },
+  { path: 'dealValue.offer', type: 'number', label: 'Deal value (offer)' },
+  { path: 'discountDepth.rule', type: 'number', label: 'Rule discount depth', optional: true },
+  { path: 'discountDepth.manual', type: 'number', label: 'Manual discount depth', optional: true },
+  { path: 'discountDepth.total', type: 'number', label: 'Total discount depth', optional: true },
+  { path: 'discountDepth.maxLineManual', type: 'number', label: 'Max line manual discount depth', optional: true },
+  { path: 'hasTimeBasedAdjustments', type: 'boolean' },
+  { path: 'occurredAt', type: 'date' },
+]
 
 /**
  * CPQ Module Events.
@@ -8,8 +30,9 @@ import { createModuleEvents } from '@open-mercato/shared/modules/events'
  * modules (billing, notifications) subscribe to these to react to
  * subscription mutations driven by CPQ orders.
  *
- * Emission rule: events fire AFTER the activation transaction commits.
- * `cpqOrderService.activateOrder` is the sole emitter site.
+ * Emission rule: events fire AFTER their transaction commits.
+ * Subscription events: `cpqOrderService.activateOrder` is the sole emitter.
+ * Quote events: `withQuotePricingWrite` (plus `cloneQuote` for the copy).
  */
 const events = [
   {
@@ -54,6 +77,34 @@ const events = [
     category: 'lifecycle',
     clientBroadcast: true,
   },
+  // Quote pricing signals (manual price adjustments). Emitted after the quote
+  // write commits by `withQuotePricingWrite`; payload carries the pricing
+  // snapshot (deal value, discount depth, snapshot hash) so project workflows
+  // can route approvals without CPQ code.
+  {
+    id: 'cpq.quote.pricing_changed',
+    label: 'Quote Pricing Changed',
+    entity: 'quote',
+    category: 'custom',
+    clientBroadcast: true,
+    payloadSchema: { fields: [...quotePricingSnapshotFields, { path: 'cause', type: 'select' }] },
+  },
+  {
+    id: 'cpq.quote.status_changed',
+    label: 'Quote Status Changed',
+    entity: 'quote',
+    category: 'lifecycle',
+    clientBroadcast: true,
+    payloadSchema: {
+      fields: [
+        ...quotePricingSnapshotFields,
+        { path: 'fromStatus', type: 'text' },
+        { path: 'toStatus', type: 'text' },
+        { path: 'cause', type: 'select' },
+        { path: 'actorUserId', type: 'text', optional: true },
+      ],
+    },
+  },
 ] as const
 
 export const eventsConfig = createModuleEvents({