@firela/api-types 0.0.0-canary.e1146c01 → 0.0.0-canary.ebb51de2

package/src/generated/schemas.gen.ts

@@ -466,6 +466,66 @@ export const $RegionsMetadataResponseDto = {
   required: ['regions']
 } as const;
 
+export const $CostSpecDto = {
+  type: 'object',
+  properties: {
+    mode: {
+      type: 'string',
+      enum: ['per-unit', 'total', 'date', 'label', 'auto'],
+      description: 'Cost specification mode (mirrors engine CostSpec)'
+    },
+    numberPerUnit: {
+      type: 'string',
+      description: 'Per-unit cost (required when mode is "per-unit")',
+      example: '240'
+    },
+    totalNumber: {
+      type: 'string',
+      description: 'Total cost for all units (required when mode is "total")',
+      example: '12000'
+    },
+    currency: {
+      type: 'string',
+      description: 'Cost currency (required in all modes)',
+      example: 'USD'
+    },
+    date: {
+      type: 'string',
+      description:
+        'Lot acquisition date, ISO 8601 (required when mode is "date")',
+      example: '2024-01-15'
+    },
+    label: {
+      type: 'string',
+      description:
+        'Lot label (required when mode is "label"; optional tag in buy modes)'
+    },
+    merge: {
+      type: 'boolean',
+      description: 'Merge lots for AVERAGE booking (mode: auto)'
+    }
+  },
+  required: ['mode', 'currency']
+} as const;
+
+export const $AmountDto = {
+  type: 'object',
+  properties: {
+    number: {
+      type: 'string',
+      description:
+        'Amount as decimal string (max 15 integer + 15 decimal digits)',
+      example: '170.50'
+    },
+    currency: {
+      type: 'string',
+      description: 'Currency/commodity code',
+      example: 'USD'
+    }
+  },
+  required: ['number', 'currency']
+} as const;
+
 export const $CreatePostingDto = {
   type: 'object',
   properties: {
@@ -495,6 +555,33 @@ export const $CreatePostingDto = {
       example: {
         'tax-lot': 'Q1-2024'
       }
+    },
+    cost: {
+      description:
+        'Cost basis (Beancount `{...}`). Maps to engine costSpec. Required for commodity holdings so they carry a monetary weight that can balance.',
+      example: {
+        mode: 'per-unit',
+        numberPerUnit: '240',
+        currency: 'USD'
+      },
+      allOf: [
+        {
+          $ref: '#/components/schemas/CostSpecDto'
+        }
+      ]
+    },
+    price: {
+      description:
+        'Price annotation (Beancount `@...`). Maps to engine price. Used for valuation; cost takes priority for balance weight.',
+      example: {
+        number: '170',
+        currency: 'USD'
+      },
+      allOf: [
+        {
+          $ref: '#/components/schemas/AmountDto'
+        }
+      ]
     }
   },
   required: ['account']
@@ -573,6 +660,32 @@ export const $CreateTransactionDto = {
   required: ['date', 'narration', 'postings']
 } as const;
 
+export const $CostDetailDto = {
+  type: 'object',
+  properties: {
+    number: {
+      type: 'string',
+      description: 'Per-unit cost basis (mirrors engine Cost.number)',
+      example: '240'
+    },
+    currency: {
+      type: 'string',
+      description: 'Cost currency',
+      example: 'USD'
+    },
+    date: {
+      type: 'string',
+      description: 'Lot acquisition date (ISO yyyy-mm-dd)',
+      example: '2024-01-15'
+    },
+    label: {
+      type: 'string',
+      description: 'Lot label',
+      example: 'lot-2024-01'
+    }
+  }
+} as const;
+
 export const $PostingResponseDto = {
   type: 'object',
   properties: {
@@ -591,6 +704,15 @@ export const $PostingResponseDto = {
       type: 'string',
       description: 'Currency',
       example: 'USD'
+    },
+    cost: {
+      description:
+        'Booking-resolved cost (mirrors engine Cost). Undefined when the posting has no cost basis.',
+      allOf: [
+        {
+          $ref: '#/components/schemas/CostDetailDto'
+        }
+      ]
     }
   },
   required: ['account']
@@ -933,9 +1055,9 @@ export const $PostingDetailDto = {
       description: 'Account ID',
       example: 'clh1234567890abcdef'
     },
-    accountName: {
+    account: {
       type: 'string',
-      description: 'Account name',
+      description: 'Fully-qualified Beancount account path',
       example: 'Assets:Bank:Checking'
     },
     units: {
@@ -964,6 +1086,15 @@ export const $PostingDetailDto = {
       description: 'Cost date',
       example: '2024-01-15'
     },
+    cost: {
+      description:
+        'Booking-resolved cost (mirrors engine Cost). Undefined when the posting has no cost basis.',
+      allOf: [
+        {
+          $ref: '#/components/schemas/CostDetailDto'
+        }
+      ]
+    },
     priceAmount: {
       type: 'string',
       description: 'Price amount',
@@ -984,7 +1115,7 @@ export const $PostingDetailDto = {
       description: 'Posting metadata'
     }
   },
-  required: ['id', 'accountId', 'accountName']
+  required: ['id', 'accountId', 'account']
 } as const;
 
 export const $TransactionDetailDto = {
@@ -4780,49 +4911,6 @@ export const $ProviderSyncDto = {
   required: ['config', 'transactions']
 } as const;
 
-export const $ProviderSyncResponseDto = {
-  type: 'object',
-  properties: {
-    imported: {
-      type: 'number',
-      description: 'Number of transactions successfully imported',
-      example: 10
-    },
-    skipped: {
-      type: 'number',
-      description: 'Number of transactions skipped (duplicates)',
-      example: 2
-    },
-    pendingReview: {
-      type: 'number',
-      description: 'Number of transactions pending review',
-      example: 3
-    },
-    failed: {
-      type: 'number',
-      description: 'Number of transactions that failed to import',
-      example: 0
-    },
-    importedTransactionIds: {
-      description: 'IDs of successfully imported transactions',
-      example: ['txn-001', 'txn-002'],
-      type: 'array',
-      items: {
-        type: 'string'
-      }
-    },
-    reviewItemIds: {
-      description: 'IDs of review items created for branched transactions',
-      example: ['review-001', 'review-002'],
-      type: 'array',
-      items: {
-        type: 'string'
-      }
-    }
-  },
-  required: ['imported', 'skipped', 'pendingReview', 'failed']
-} as const;
-
 export const $SupportedProvidersResponseDto = {
   type: 'object',
   properties: {
@@ -4852,6 +4940,11 @@ export const $ParserTelemetryReportDto = {
   properties: {}
 } as const;
 
+export const $UncoveredFormatMissDto = {
+  type: 'object',
+  properties: {}
+} as const;
+
 export const $ProcessNlpDto = {
   type: 'object',
   properties: {
@@ -4881,825 +4974,599 @@ export const $ProcessNlpDto = {
   required: ['message']
 } as const;
 
-export const $NlpTransactionInfoDto = {
+export const $BalanceByCurrencyDto = {
   type: 'object',
   properties: {
-    id: {
-      type: 'string',
-      description: 'Transaction ID'
-    },
-    date: {
-      type: 'string',
-      description: 'Transaction date (ISO format)'
-    },
-    amount: {
-      type: 'number',
-      description: 'Transaction amount'
-    },
     currency: {
       type: 'string',
-      description: 'Currency code'
-    },
-    payee: {
-      type: 'string',
-      description: 'Payee name'
-    },
-    narration: {
-      type: 'string',
-      description: 'Transaction narration'
+      description: 'ISO 4217 currency code',
+      example: 'CNY'
     },
-    warning: {
+    balance: {
       type: 'string',
-      description:
-        'Warning message for special transaction scenarios (e.g., cross-currency settlement)',
-      example: '此交易使用USD账户结算。如需记录CNY支出，请创建货币转换交易。'
+      description: 'Balance amount',
+      example: '50000.00'
     }
   },
-  required: ['id', 'date', 'amount', 'currency']
+  required: ['currency', 'balance']
 } as const;
 
-export const $NlpParsedDataDto = {
+export const $NetWorthByCurrencyDto = {
   type: 'object',
   properties: {
-    amount: {
-      type: 'number',
-      description: 'Extracted amount'
-    },
-    currency: {
-      type: 'string',
-      description: 'Currency code',
-      default: 'CNY'
-    },
-    date: {
-      type: 'string',
-      description: 'Transaction date (ISO format)'
-    },
-    payee: {
-      type: 'string',
-      description: 'Payee name'
-    },
-    narration: {
-      type: 'string',
-      description: 'Transaction narration'
-    },
-    category: {
-      type: 'string',
-      description: 'Category'
-    },
-    incomeType: {
-      type: 'string',
-      description: 'Income type (e.g., Salary, Bonus, Dividend, Interest)',
-      example: 'Salary'
+    netWorth: {
+      description: 'Net worth by currency',
+      type: 'array',
+      items: {
+        $ref: '#/components/schemas/BalanceByCurrencyDto'
+      }
     },
-    incomeSource: {
-      type: 'string',
-      description: 'Income source (e.g., company name)',
-      example: 'Anthropic Inc.'
+    assets: {
+      description: 'Assets by currency',
+      type: 'array',
+      items: {
+        $ref: '#/components/schemas/BalanceByCurrencyDto'
+      }
     },
-    symbol: {
+    liabilities: {
+      description: 'Liabilities by currency',
+      type: 'array',
+      items: {
+        $ref: '#/components/schemas/BalanceByCurrencyDto'
+      }
+    }
+  },
+  required: ['netWorth', 'assets', 'liabilities']
+} as const;
+
+export const $ConvertedNetWorthDto = {
+  type: 'object',
+  properties: {
+    baseCurrency: {
       type: 'string',
-      description: 'Security symbol code (e.g., 600519, AAPL)',
-      example: '600519'
-    },
-    quantity: {
-      type: 'number',
-      description: 'Quantity of shares/units',
-      example: 100
-    },
-    price: {
-      type: 'number',
-      description: 'Unit price per share/unit',
-      example: 1900
+      description: 'Base currency for conversion',
+      example: 'CNY'
     },
-    investmentAction: {
+    netWorth: {
       type: 'string',
-      description: 'Investment action',
-      enum: ['buy', 'sell'],
-      example: 'buy'
+      description: 'Converted net worth',
+      example: '500000.00'
     },
-    paymentSource: {
+    assets: {
       type: 'string',
-      description: 'Payment source: asset (default) or liability (credit card)',
-      enum: ['asset', 'liability'],
-      example: 'asset'
+      description: 'Converted assets',
+      example: '600000.00'
     },
-    liabilityHint: {
+    liabilities: {
       type: 'string',
-      description: 'Liability account hint (CreditCard/Huabei/Baitiao)',
-      example: 'CreditCard'
+      description: 'Converted liabilities',
+      example: '100000.00'
     },
-    warning: {
-      type: 'string',
-      description:
-        'Warning message for special scenarios (e.g., cross-currency settlement)',
-      example: '此交易使用USD账户结算。如需记录CNY支出，请创建货币转换交易。'
+    exchangeRates: {
+      type: 'object',
+      description: 'Exchange rates used for conversion',
+      example: {
+        USD: '7.200000',
+        EUR: '7.800000'
+      }
     }
-  }
+  },
+  required: [
+    'baseCurrency',
+    'netWorth',
+    'assets',
+    'liabilities',
+    'exchangeRates'
+  ]
 } as const;
 
-export const $NlpSourceTransactionDto = {
+export const $ExchangeRateWarningDto = {
   type: 'object',
   properties: {
-    date: {
-      type: 'string',
-      description: 'Transaction date (ISO format)'
-    },
-    amount: {
+    type: {
       type: 'string',
-      description: 'Amount as string'
+      description: 'Warning type',
+      example: 'MISSING_EXCHANGE_RATE'
     },
     currency: {
       type: 'string',
-      description: 'Currency code'
-    },
-    payee: {
-      type: 'string',
-      description: 'Payee name'
+      description: 'Currency without exchange rate',
+      example: 'EUR'
     },
-    narration: {
+    totalAmount: {
       type: 'string',
-      description: 'Transaction narration'
+      description: 'Total amount affected',
+      example: '1000.00'
     }
   },
-  required: ['date', 'amount', 'currency', 'narration']
+  required: ['type', 'currency', 'totalAmount']
 } as const;
 
-export const $NlpTargetTransactionDto = {
+export const $NetWorthResponseDto = {
   type: 'object',
   properties: {
-    id: {
+    netWorth: {
       type: 'string',
-      description: 'Existing transaction ID'
+      description:
+        'Total net worth (assets - liabilities, converted to base currency)',
+      example: '500000.00'
     },
-    date: {
+    assets: {
       type: 'string',
-      description: 'Transaction date (ISO format)'
+      description: 'Total assets value (converted)',
+      example: '600000.00'
     },
-    amount: {
+    liabilities: {
       type: 'string',
-      description: 'Amount as string'
+      description: 'Total liabilities value (positive number, converted)',
+      example: '100000.00'
     },
-    currency: {
+    monthlyReturn: {
       type: 'string',
-      description: 'Currency code'
+      description: 'Monthly return (change from last month)',
+      example: '15000.00'
     },
-    payee: {
+    monthlyReturnPercentage: {
       type: 'string',
-      description: 'Payee name'
+      description: 'Monthly return percentage',
+      example: '3.15'
     },
-    narration: {
+    currency: {
       type: 'string',
-      description: 'Transaction narration'
-    }
-  },
-  required: ['id', 'date', 'amount', 'currency', 'narration']
-} as const;
-
-export const $NlpSimilarityDto = {
-  type: 'object',
-  properties: {
-    dateMatch: {
-      type: 'boolean',
-      description: 'Whether dates match'
-    },
-    dateDiff: {
-      type: 'number',
-      description: 'Date difference in days'
-    },
-    amountMatch: {
-      type: 'boolean',
-      description: 'Whether amounts match'
+      description: 'Base currency code',
+      example: 'CNY'
     },
-    amountDiff: {
+    asOf: {
       type: 'string',
-      description: 'Amount difference as decimal string'
-    },
-    payeeMatch: {
-      type: 'boolean',
-      description: 'Whether payees match'
-    },
-    payeeSimilarity: {
-      type: 'number',
-      description: 'Payee similarity score (0-1)'
-    },
-    accountOverlap: {
-      type: 'number',
-      description: 'Account overlap score (0-1)'
-    }
-  },
-  required: [
-    'dateMatch',
-    'dateDiff',
-    'amountMatch',
-    'amountDiff',
-    'payeeMatch',
-    'payeeSimilarity',
-    'accountOverlap'
-  ]
-} as const;
-
-export const $NlpDuplicateConfirmationDataDto = {
-  type: 'object',
-  properties: {
-    confidence: {
-      type: 'number',
-      description: 'Duplicate detection confidence score (0.5-0.89)',
-      example: 0.85
-    },
-    sourceTransaction: {
-      description:
-        'Source transaction summary (the new transaction being entered)',
-      allOf: [
-        {
-          $ref: '#/components/schemas/NlpSourceTransactionDto'
-        }
-      ]
+      description: 'Data as of date (ISO 8601)',
+      example: '2024-06-15T00:00:00.000Z'
     },
-    targetTransaction: {
-      description: 'Target transaction summary (existing potential duplicate)',
+    byCurrency: {
+      description: 'Balances grouped by original currency',
       allOf: [
         {
-          $ref: '#/components/schemas/NlpTargetTransactionDto'
+          $ref: '#/components/schemas/NetWorthByCurrencyDto'
         }
       ]
     },
-    similarity: {
-      description: 'Detailed similarity information',
+    converted: {
+      description:
+        'Converted values in base currency (undefined if no exchange rates available)',
       allOf: [
         {
-          $ref: '#/components/schemas/NlpSimilarityDto'
+          $ref: '#/components/schemas/ConvertedNetWorthDto'
         }
       ]
     },
-    reasons: {
-      description: 'Human-readable reasons for duplicate detection',
-      example: ['日期匹配', '金额匹配', '商户相似'],
-      type: 'array',
-      items: {
-        type: 'string'
-      }
-    }
-  },
-  required: [
-    'confidence',
-    'sourceTransaction',
-    'targetTransaction',
-    'similarity',
-    'reasons'
-  ]
-} as const;
-
-export const $NlpRuleConfirmationDataDto = {
-  type: 'object',
-  properties: {
-    confidence: {
-      type: 'number',
-      description: 'Rule match confidence score (0.5-0.74)',
-      example: 0.65
-    },
-    matchedRule: {
-      type: 'object',
-      description: 'Matched rule information'
-    },
-    suggestedAccounts: {
-      type: 'object',
-      description: 'Suggested accounts from the rule'
-    },
-    alternatives: {
-      type: 'array',
-      description: 'Alternative rules that also match'
-    },
-    reasons: {
-      description: 'Human-readable reasons for the match',
-      example: [
-        'Moderate confidence (65%)',
-        'Some keywords matched (OR logic)'
-      ],
+    warnings: {
+      description: 'Exchange rate warnings',
       type: 'array',
       items: {
-        type: 'string'
+        $ref: '#/components/schemas/ExchangeRateWarningDto'
       }
     }
   },
   required: [
-    'confidence',
-    'matchedRule',
-    'suggestedAccounts',
-    'alternatives',
-    'reasons'
+    'netWorth',
+    'assets',
+    'liabilities',
+    'monthlyReturn',
+    'monthlyReturnPercentage',
+    'currency',
+    'asOf'
   ]
 } as const;
 
-export const $NlpAccountConfirmationDataDto = {
+export const $AccountItemDto = {
   type: 'object',
   properties: {
-    invalidAccount: {
+    id: {
       type: 'string',
-      description: 'The invalid account name',
-      example: 'Expenses:Food:Coffee'
+      description: 'Account ID'
     },
-    suggestedAccount: {
+    name: {
       type: 'string',
-      description: 'Suggested replacement account',
-      example: 'Expenses:Food:Drinks'
+      description: 'Full account name',
+      example: 'Assets:Bank:CMB:Savings'
     },
-    similarAccounts: {
-      description: 'Similar accounts for user selection',
-      type: 'array',
-      items: {
-        type: 'string'
-      }
+    displayName: {
+      type: 'string',
+      description: 'Display name (last part of account path)',
+      example: 'Savings'
     },
-    errorMessage: {
+    balance: {
       type: 'string',
-      description: 'Error message explaining the issue',
-      example: 'No similar account found'
+      description: 'Account balance',
+      example: '50000.00'
     },
-    transactionContext: {
-      type: 'object',
-      description: 'Transaction context for reference'
+    currency: {
+      type: 'string',
+      description: 'Currency code',
+      example: 'CNY'
     }
   },
-  required: [
-    'invalidAccount',
-    'suggestedAccount',
-    'similarAccounts',
-    'errorMessage',
-    'transactionContext'
-  ]
+  required: ['id', 'name', 'displayName', 'balance', 'currency']
 } as const;
 
-export const $NlpSuggestedPayeeDto = {
+export const $PlatformGroupDto = {
   type: 'object',
   properties: {
-    id: {
-      type: 'string',
-      description: 'Payee ID',
-      example: 'payee-123'
-    },
-    name: {
+    platformId: {
       type: 'string',
-      description: 'Payee name',
-      example: 'Starbucks'
+      description: 'Platform ID'
     },
-    category: {
+    platformName: {
       type: 'string',
-      description: 'Payee category',
-      example: 'food'
+      description: 'Platform display name',
+      example: 'CMB Bank'
     },
-    source: {
-      type: 'string',
-      description: 'Source of the payee',
-      enum: ['user', 'global']
+    accounts: {
+      description: 'Accounts within this platform',
+      type: 'array',
+      items: {
+        $ref: '#/components/schemas/AccountItemDto'
+      }
     },
-    payeeProfileId: {
+    totalBalance: {
       type: 'string',
-      description: 'PayeeProfile ID (if matched from global)',
-      example: 'profile-456'
+      description: 'Total balance across all accounts in platform',
+      example: '100000.00'
     }
   },
-  required: ['id', 'name']
+  required: ['platformId', 'platformName', 'accounts', 'totalBalance']
 } as const;
 
-export const $NlpAlternativePayeeDto = {
+export const $AccountsSummaryDto = {
   type: 'object',
   properties: {
-    id: {
-      type: 'string',
-      description: 'Payee ID',
-      example: 'payee-alt-1'
-    },
-    name: {
-      type: 'string',
-      description: 'Payee name',
-      example: 'Starbucks Coffee'
+    totalAccounts: {
+      type: 'number',
+      description: 'Total number of accounts'
     },
-    similarity: {
+    totalPlatforms: {
       type: 'number',
-      description: 'Similarity score (0-1)',
-      example: 0.75
+      description: 'Total number of platforms'
     }
   },
-  required: ['id', 'name', 'similarity']
+  required: ['totalAccounts', 'totalPlatforms']
 } as const;
 
-export const $NlpPayeeConfirmationDataDto = {
+export const $AccountsResponseDto = {
   type: 'object',
   properties: {
-    confidence: {
-      type: 'number',
-      description: 'Confidence score for the payee match (0-1)',
-      example: 0.65
-    },
-    originalPayee: {
-      type: 'string',
-      description: 'Original payee string from user input',
-      example: '星巴'
+    groups: {
+      description: 'Account groups by platform',
+      type: 'array',
+      items: {
+        $ref: '#/components/schemas/PlatformGroupDto'
+      }
     },
-    suggestedPayee: {
-      description: 'Suggested payee to use (null when no similar payees found)',
-      nullable: true,
+    summary: {
+      description: 'Summary statistics',
       allOf: [
         {
-          $ref: '#/components/schemas/NlpSuggestedPayeeDto'
+          $ref: '#/components/schemas/AccountsSummaryDto'
         }
       ]
-    },
-    similarity: {
-      type: 'number',
-      description: 'Similarity score between original and suggested (0-1)',
-      example: 0.85
-    },
-    alternatives: {
-      description: 'Alternative payee options',
-      type: 'array',
-      items: {
-        $ref: '#/components/schemas/NlpAlternativePayeeDto'
-      }
-    },
-    reasons: {
-      description: 'Human-readable reasons for the match',
-      example: ['Moderate similarity (65%)', 'Fuzzy match on name'],
-      type: 'array',
-      items: {
-        type: 'string'
-      }
     }
   },
-  required: [
-    'confidence',
-    'originalPayee',
-    'similarity',
-    'alternatives',
-    'reasons'
-  ]
+  required: ['groups', 'summary']
 } as const;
 
-export const $RecurringMatchInfoDto = {
+export const $AccountItemWithAssetClassDto = {
   type: 'object',
   properties: {
-    expectedId: {
+    id: {
       type: 'string',
-      description: 'Expected transaction ID'
+      description: 'Account ID'
     },
-    ruleId: {
+    name: {
       type: 'string',
-      description: 'Recurring rule ID'
+      description: 'Full account name',
+      example: 'Assets:Bank:CMB:Savings'
     },
-    ruleName: {
+    displayName: {
       type: 'string',
-      description: 'Rule name for display'
+      description: 'Display name (last part of account path)',
+      example: 'Savings'
     },
-    ruleIcon: {
+    balance: {
       type: 'string',
-      description: 'Rule icon'
+      description: 'Account balance',
+      example: '50000.00'
     },
-    expectedDate: {
+    currency: {
       type: 'string',
-      description: 'Expected date (YYYY-MM-DD)',
-      example: '2026-01-05'
+      description: 'Currency code',
+      example: 'CNY'
     },
-    expectedAmount: {
-      type: 'number',
-      description: 'Expected amount',
-      example: 3000
+    assetClass: {
+      type: 'string',
+      description: 'Asset class',
+      example: 'LIQUIDITY'
     },
-    confidence: {
-      type: 'number',
-      description: 'Match confidence score (0-1)',
-      example: 0.88
+    assetSubClass: {
+      type: 'string',
+      description: 'Asset sub-class (Prisma-compatible)',
+      example: 'RETIREMENT_ACCOUNT'
     },
-    isAutoMatched: {
-      type: 'boolean',
-      description: 'Whether auto-matched (confidence >= 0.82)'
-    }
-  },
-  required: [
-    'expectedId',
-    'ruleId',
-    'ruleName',
-    'expectedDate',
-    'expectedAmount',
-    'confidence',
-    'isAutoMatched'
-  ]
-} as const;
-
-export const $NlpSuggestedAccountDto = {
-  type: 'object',
-  properties: {
-    account: {
+    regionalSubClass: {
       type: 'string',
-      description: 'Suggested account path',
-      example: 'Assets:Bank:Checking'
+      description: 'Regional sub-class (region-specific, for display)',
+      example: 'FOUR_ZERO_ONE_K'
     },
-    confidence: {
-      type: 'number',
-      description: 'Confidence score for this suggestion (0-1)',
-      example: 0.9
-    }
-  },
-  required: ['account']
-} as const;
-
-export const $NlpSuggestedAccountsDto = {
-  type: 'object',
-  properties: {
-    source: {
-      description:
-        'Source account suggestion (where money comes from). For expense: asset/liability account. For income: income account.',
-      allOf: [
-        {
-          $ref: '#/components/schemas/NlpSuggestedAccountDto'
-        }
-      ]
+    riskLevel: {
+      type: 'string',
+      description: 'Risk level',
+      example: 'LOW'
     },
-    destination: {
+    source: {
+      type: 'string',
       description:
-        'Destination account suggestion (where money goes to). For expense: expense account. For income: asset/liability account.',
-      allOf: [
-        {
-          $ref: '#/components/schemas/NlpSuggestedAccountDto'
-        }
-      ]
+        'ADR-0105 classification provenance (holding level always; account level only on FALLBACK)',
+      enum: ['USER_META', 'FIAT_CURRENCY', 'OPENBB_MAPPING', 'FALLBACK']
     }
-  }
+  },
+  required: ['id', 'name', 'displayName', 'balance', 'currency', 'assetClass']
 } as const;
 
-export const $NlpDefaultAccountsDto = {
+export const $AssetClassGroupDto = {
   type: 'object',
   properties: {
-    asset: {
+    assetClass: {
       type: 'string',
-      description: 'Default asset account',
-      example: 'Assets:Bank:Checking'
+      description: 'Asset class name',
+      example: 'LIQUIDITY',
+      enum: [
+        'LIQUIDITY',
+        'EQUITY',
+        'FIXED_INCOME',
+        'PRECIOUS_METALS',
+        'COMMODITY',
+        'INSURANCE',
+        'ALTERNATIVE_INVESTMENT',
+        'PERSONAL_ASSETS',
+        'LIABILITY',
+        'REAL_ESTATE',
+        'INDEX'
+      ]
     },
-    expense: {
+    assetSubClass: {
       type: 'string',
-      description: 'Default expense account',
-      example: 'Expenses:Uncategorized'
+      description: 'Asset sub-class name',
+      example: 'DEPOSIT'
     },
-    income: {
-      type: 'string',
-      description: 'Default income account',
-      example: 'Income:Uncategorized'
+    accounts: {
+      description: 'Accounts within this asset class',
+      type: 'array',
+      items: {
+        $ref: '#/components/schemas/AccountItemWithAssetClassDto'
+      }
+    },
+    balanceByCurrency: {
+      description: 'Balances grouped by currency',
+      type: 'array',
+      items: {
+        $ref: '#/components/schemas/BalanceByCurrencyDto'
+      }
     },
-    liability: {
+    convertedBalance: {
       type: 'string',
-      description: 'Default liability account',
-      example: 'Liabilities:CreditCard'
+      description: 'Converted balance in base currency',
+      example: '100000.00'
     }
   },
-  required: ['asset', 'expense', 'income', 'liability']
+  required: ['assetClass', 'accounts', 'balanceByCurrency']
 } as const;
 
-export const $NlpResponseDto = {
+export const $AccountExchangeRateWarningDto = {
   type: 'object',
   properties: {
-    status: {
-      type: 'string',
-      description: 'Response status',
-      enum: ['success', 'pending', 'error']
-    },
-    action: {
-      type: 'string',
-      description: 'Action taken or requested',
-      enum: [
-        'created',
-        'ask',
-        'confirm',
-        'confirm_duplicate',
-        'confirm_rule',
-        'confirm_account',
-        'confirm_payee',
-        'cancel'
-      ]
-    },
-    intent: {
-      type: 'string',
-      description:
-        'Transaction intent detected by EntityRouter (v6.0: 5 core intents). Frontend uses this to render scenario-specific form fields.',
-      enum: ['expense', 'asset', 'income', 'liability', 'equity'],
-      example: 'expense'
-    },
-    assetSubType: {
+    type: {
       type: 'string',
-      description:
-        'Asset sub-type (only present when intent is "asset"). Determines which asset-related form to render.',
-      enum: ['transfer', 'banking', 'investment'],
-      example: 'investment'
+      description: 'Warning type',
+      example: 'MISSING_EXCHANGE_RATE'
     },
-    liabilitySubType: {
+    currency: {
       type: 'string',
-      description:
-        'Liability sub-type (only present when intent is "liability"). borrow: borrowing money (Liabilities → Assets), repay: repaying debt (Assets → Liabilities).',
-      enum: ['borrow', 'repay'],
-      example: 'borrow'
+      description: 'Currency without exchange rate',
+      example: 'USD'
     },
-    equitySubType: {
-      type: 'string',
-      description:
-        'Equity sub-type (only present when intent is "equity"). opening: account opening balance (Equity → Assets), adjustment: balance correction.',
-      enum: ['opening', 'adjustment'],
-      example: 'opening'
+    accounts: {
+      description: 'Affected account paths',
+      type: 'array',
+      items: {
+        type: 'string'
+      }
     },
-    paymentSource: {
+    totalAmount: {
       type: 'string',
-      description:
-        'Payment source for expense transactions (v6.1). Indicates whether payment comes from asset or liability account. Only present when intent is "expense".',
-      enum: ['asset', 'liability'],
-      example: 'liability'
+      description: 'Total amount in this currency',
+      example: '5000.00'
+    }
+  },
+  required: ['type', 'currency', 'accounts', 'totalAmount']
+} as const;
+
+export const $AssetClassSummaryDto = {
+  type: 'object',
+  properties: {
+    totalAccounts: {
+      type: 'number',
+      description: 'Total number of accounts'
     },
-    liabilityHint: {
-      type: 'string',
-      description:
-        'Liability account type hint for credit card/BNPL spending (v6.1). Only present when paymentSource is "liability". Values: CreditCard, Huabei, Baitiao',
-      example: 'CreditCard'
+    totalAssetClasses: {
+      type: 'number',
+      description: 'Total number of asset classes'
     },
-    message: {
+    baseCurrency: {
       type: 'string',
-      description:
-        'Human-readable message (for ask or error actions). Deprecated: Use messageKey for i18n support.',
-      example: 'How much did you spend?',
-      deprecated: true
+      description: 'Base currency for conversion',
+      example: 'CNY'
     },
-    messageKey: {
-      type: 'string',
-      description:
-        'i18n message key for frontend translation. Use this instead of message for internationalization support.',
-      example: 'nlp.slot.prompt'
+    warnings: {
+      description: 'Exchange rate warnings',
+      type: 'array',
+      items: {
+        $ref: '#/components/schemas/AccountExchangeRateWarningDto'
+      }
     },
-    messageParams: {
+    fallback: {
       type: 'object',
       description:
-        'Parameters for message interpolation. Used with messageKey for dynamic values in translated messages.',
-      example: {
-        slot: 'amount',
-        name: 'Starbucks',
-        similarity: 85
+        'ADR-0105 §4 fallback provenance stats (holding level only). valueRatio is the grey-area share of total converted value; count is the number of source=FALLBACK holdings.'
+    }
+  },
+  required: ['totalAccounts', 'totalAssetClasses', 'baseCurrency']
+} as const;
+
+export const $AssetClassAccountsResponseDto = {
+  type: 'object',
+  properties: {
+    groups: {
+      description: 'Account groups by asset class',
+      type: 'array',
+      items: {
+        $ref: '#/components/schemas/AssetClassGroupDto'
       }
     },
-    sessionId: {
-      type: 'string',
-      description:
-        'Session ID for multi-turn dialogue. Must be included in subsequent requests to continue the conversation.',
-      example: 'session_abc123'
-    },
-    waitingFor: {
-      type: 'string',
-      description: 'Which slot is waiting for user input',
-      example: 'amount'
-    },
-    transaction: {
-      description: 'Created transaction info (for created action)',
-      allOf: [
-        {
-          $ref: '#/components/schemas/NlpTransactionInfoDto'
-        }
-      ]
-    },
-    parsedData: {
-      description:
-        'Parsed data for confirmation (when action is "confirm"). Contains extracted fields that user should verify before transaction creation.',
+    summary: {
+      description: 'Summary statistics',
       allOf: [
         {
-          $ref: '#/components/schemas/NlpParsedDataDto'
+          $ref: '#/components/schemas/AssetClassSummaryDto'
         }
       ]
     },
-    duplicateData: {
+    uncategorized: {
       description:
-        'Duplicate detection data (when action is "confirm_duplicate"). Contains information about potential duplicate transaction for user confirmation.',
+        'ADR-0105 §6 holding-level grey-area bucket (source=FALLBACK holdings peeled out of groups). Present only for groupBy=holdingAssetClass when FALLBACK holdings exist.',
       allOf: [
         {
-          $ref: '#/components/schemas/NlpDuplicateConfirmationDataDto'
+          $ref: '#/components/schemas/AssetClassGroupDto'
         }
       ]
+    }
+  },
+  required: ['groups', 'summary']
+} as const;
+
+export const $HoldingAssetClassAccountSliceDto = {
+  type: 'object',
+  properties: {
+    accountId: {
+      type: 'string',
+      description: 'Account ID'
     },
-    ruleData: {
-      description:
-        'Rule match data (when action is "confirm_rule"). Contains information about medium-confidence rule match for user confirmation.',
-      allOf: [
-        {
-          $ref: '#/components/schemas/NlpRuleConfirmationDataDto'
-        }
-      ]
+    accountPath: {
+      type: 'string',
+      description: 'Full account path',
+      example: 'Assets:US:Investments:Brokerage'
     },
-    accountData: {
+    accountCurrency: {
+      type: 'string',
       description:
-        'Account validation data (when action is "confirm_account"). Contains information about invalid account for user correction.',
-      allOf: [
-        {
-          $ref: '#/components/schemas/NlpAccountConfirmationDataDto'
-        }
-      ]
+        'Currency of the holding with the largest converted base value; undefined when no holding is convertible',
+      example: 'USD'
     },
-    payeeData: {
+    marketValueBase: {
+      type: 'string',
       description:
-        'Payee confirmation data (when action is "confirm_payee"). Contains information about medium/low confidence payee match for user confirmation.',
-      allOf: [
-        {
-          $ref: '#/components/schemas/NlpPayeeConfirmationDataDto'
-        }
-      ]
-    },
-    confidence: {
-      type: 'number',
-      description: 'Overall confidence score (0-1)',
-      example: 0.85
+        "Account's market value in base currency (Σ converted holdings; grey bucket included)",
+      example: '50000.00'
     },
-    confidenceThreshold: {
+    shareOfTotalPct: {
       type: 'number',
       description:
-        'Confidence threshold for automatic creation (default: 0.75). When confidence < threshold, action will be "confirm" requiring user verification.',
-      example: 0.75
-    },
-    recurringMatch: {
-      description:
-        'Recurring transaction match info (when action is "created"). Contains match details when transaction matches a pending expected transaction.',
-      allOf: [
-        {
-          $ref: '#/components/schemas/RecurringMatchInfoDto'
-        }
-      ]
+        'Share of the global total (0-100). 0 when globalTotal is zero (no NaN/Infinity).',
+      example: 42.5
     },
-    recurringSuggestion: {
-      description:
-        'Recurring rule creation suggestion (when action is "created"). Contains suggestion to create a recurring rule based on detected patterns. Only present when no existing rule matched and similar historical transactions were found.',
-      allOf: [
-        {
-          $ref: '#/components/schemas/RecurringSuggestionDto'
-        }
-      ]
+    groups: {
+      description: 'Per-account asset-class breakdown',
+      type: 'array',
+      items: {
+        $ref: '#/components/schemas/AssetClassGroupDto'
+      }
     },
-    suggestedAccounts: {
+    uncategorized: {
       description:
-        'Suggested accounts for this transaction. Contains recommended source and destination accounts based on the detected intent and rules.',
+        'Per-account grey bucket (source=FALLBACK holdings, incl. broker cash)',
       allOf: [
         {
-          $ref: '#/components/schemas/NlpSuggestedAccountsDto'
+          $ref: '#/components/schemas/AssetClassGroupDto'
         }
       ]
     },
-    defaultAccounts: {
+    holdings: {
       description:
-        'Default accounts for the user/region. These are fallback accounts used when no specific suggestion is available.',
-      allOf: [
-        {
-          $ref: '#/components/schemas/NlpDefaultAccountsDto'
-        }
-      ]
+        'Every holding row for this account (account ID in each row’s `id` field)',
+      type: 'array',
+      items: {
+        $ref: '#/components/schemas/AccountItemWithAssetClassDto'
+      }
     }
   },
-  required: ['status', 'action']
+  required: [
+    'accountId',
+    'accountPath',
+    'marketValueBase',
+    'shareOfTotalPct',
+    'groups',
+    'holdings'
+  ]
 } as const;
 
-export const $BalanceByCurrencyDto = {
+export const $HoldingAssetClassCrossAccountResponseDto = {
   type: 'object',
   properties: {
-    currency: {
-      type: 'string',
-      description: 'ISO 4217 currency code',
-      example: 'CNY'
+    global: {
+      description: 'Merged cross-account holding aggregation',
+      allOf: [
+        {
+          $ref: '#/components/schemas/AssetClassAccountsResponseDto'
+        }
+      ]
     },
-    balance: {
-      type: 'string',
-      description: 'Balance amount',
-      example: '50000.00'
+    byAccount: {
+      description: 'Per-account slices',
+      type: 'array',
+      items: {
+        $ref: '#/components/schemas/HoldingAssetClassAccountSliceDto'
+      }
     }
   },
-  required: ['currency', 'balance']
+  required: ['global', 'byAccount']
 } as const;
 
-export const $NetWorthByCurrencyDto = {
+export const $CashFlowByCurrencyDto = {
   type: 'object',
   properties: {
-    netWorth: {
-      description: 'Net worth by currency',
+    income: {
+      description: 'Income by currency',
       type: 'array',
       items: {
         $ref: '#/components/schemas/BalanceByCurrencyDto'
       }
     },
-    assets: {
-      description: 'Assets by currency',
+    expense: {
+      description: 'Expense by currency',
       type: 'array',
       items: {
         $ref: '#/components/schemas/BalanceByCurrencyDto'
       }
     },
-    liabilities: {
-      description: 'Liabilities by currency',
-      type: 'array',
+    netSavings: {
+      description: 'Net savings by currency',
+      type: 'array',
       items: {
         $ref: '#/components/schemas/BalanceByCurrencyDto'
       }
     }
   },
-  required: ['netWorth', 'assets', 'liabilities']
+  required: ['income', 'expense', 'netSavings']
 } as const;
 
-export const $ConvertedNetWorthDto = {
+export const $ConvertedCashFlowDto = {
   type: 'object',
   properties: {
     baseCurrency: {
@@ -5707,114 +5574,78 @@ export const $ConvertedNetWorthDto = {
       description: 'Base currency for conversion',
       example: 'CNY'
     },
-    netWorth: {
+    income: {
       type: 'string',
-      description: 'Converted net worth',
-      example: '500000.00'
+      description: 'Converted income',
+      example: '25000.00'
     },
-    assets: {
+    expense: {
       type: 'string',
-      description: 'Converted assets',
-      example: '600000.00'
+      description: 'Converted expense',
+      example: '18000.00'
     },
-    liabilities: {
+    netSavings: {
       type: 'string',
-      description: 'Converted liabilities',
-      example: '100000.00'
+      description: 'Converted net savings',
+      example: '7000.00'
     },
     exchangeRates: {
       type: 'object',
       description: 'Exchange rates used for conversion',
       example: {
-        USD: '7.200000',
-        EUR: '7.800000'
+        USD: '7.200000'
       }
     }
   },
-  required: [
-    'baseCurrency',
-    'netWorth',
-    'assets',
-    'liabilities',
-    'exchangeRates'
-  ]
-} as const;
-
-export const $ExchangeRateWarningDto = {
-  type: 'object',
-  properties: {
-    type: {
-      type: 'string',
-      description: 'Warning type',
-      example: 'MISSING_EXCHANGE_RATE'
-    },
-    currency: {
-      type: 'string',
-      description: 'Currency without exchange rate',
-      example: 'EUR'
-    },
-    totalAmount: {
-      type: 'string',
-      description: 'Total amount affected',
-      example: '1000.00'
-    }
-  },
-  required: ['type', 'currency', 'totalAmount']
+  required: ['baseCurrency', 'income', 'expense', 'netSavings', 'exchangeRates']
 } as const;
 
-export const $NetWorthResponseDto = {
+export const $CashFlowResponseDto = {
   type: 'object',
   properties: {
-    netWorth: {
+    period: {
       type: 'string',
-      description:
-        'Total net worth (assets - liabilities, converted to base currency)',
-      example: '500000.00'
+      description: 'Period identifier (YYYY-MM)',
+      example: '2024-06'
     },
-    assets: {
+    income: {
       type: 'string',
-      description: 'Total assets value (converted)',
-      example: '600000.00'
+      description: 'Total income for the period (converted)',
+      example: '25000.00'
     },
-    liabilities: {
+    expense: {
       type: 'string',
-      description: 'Total liabilities value (positive number, converted)',
-      example: '100000.00'
+      description: 'Total expenses for the period (converted)',
+      example: '18000.00'
     },
-    monthlyReturn: {
+    netSavings: {
       type: 'string',
-      description: 'Monthly return (change from last month)',
-      example: '15000.00'
+      description: 'Net savings (income - expense, converted)',
+      example: '7000.00'
     },
-    monthlyReturnPercentage: {
+    savingsRate: {
       type: 'string',
-      description: 'Monthly return percentage',
-      example: '3.15'
+      description: 'Savings rate percentage (netSavings / income * 100)',
+      example: '28.00'
     },
     currency: {
       type: 'string',
       description: 'Base currency code',
       example: 'CNY'
     },
-    asOf: {
-      type: 'string',
-      description: 'Data as of date (ISO 8601)',
-      example: '2024-06-15T00:00:00.000Z'
-    },
     byCurrency: {
-      description: 'Balances grouped by original currency',
+      description: 'Cash flow grouped by original currency',
       allOf: [
         {
-          $ref: '#/components/schemas/NetWorthByCurrencyDto'
+          $ref: '#/components/schemas/CashFlowByCurrencyDto'
         }
       ]
     },
     converted: {
-      description:
-        'Converted values in base currency (undefined if no exchange rates available)',
+      description: 'Converted values in base currency',
       allOf: [
         {
-          $ref: '#/components/schemas/ConvertedNetWorthDto'
+          $ref: '#/components/schemas/ConvertedCashFlowDto'
         }
       ]
     },
@@ -5827,417 +5658,459 @@ export const $NetWorthResponseDto = {
     }
   },
   required: [
-    'netWorth',
-    'assets',
-    'liabilities',
-    'monthlyReturn',
-    'monthlyReturnPercentage',
-    'currency',
-    'asOf'
+    'period',
+    'income',
+    'expense',
+    'netSavings',
+    'savingsRate',
+    'currency'
   ]
 } as const;
 
-export const $AccountItemDto = {
+export const $MonetaryDto = {
   type: 'object',
   properties: {
-    id: {
-      type: 'string',
-      description: 'Account ID'
-    },
-    name: {
-      type: 'string',
-      description: 'Full account name',
-      example: 'Assets:Bank:CMB:Savings'
-    },
-    displayName: {
-      type: 'string',
-      description: 'Display name (last part of account path)',
-      example: 'Savings'
-    },
-    balance: {
+    amount: {
       type: 'string',
-      description: 'Account balance',
-      example: '50000.00'
+      description: 'Amount (Decimal string)',
+      example: '3000'
     },
     currency: {
       type: 'string',
-      description: 'Currency code',
-      example: 'CNY'
+      description: 'ISO 4217 currency',
+      example: 'USD'
+    },
+    baseCcyEquivalent: {
+      type: 'object',
+      description: 'Converted to user base currency (Decimal string)',
+      example: '21600',
+      nullable: true
     }
   },
-  required: ['id', 'name', 'displayName', 'balance', 'currency']
+  required: ['amount', 'currency']
 } as const;
 
-export const $PlatformGroupDto = {
+export const $CurrentPriceDto = {
   type: 'object',
   properties: {
-    platformId: {
+    amount: {
       type: 'string',
-      description: 'Platform ID'
+      description: 'Price amount (Decimal string)',
+      example: '250'
     },
-    platformName: {
+    currency: {
       type: 'string',
-      description: 'Platform display name',
-      example: 'CMB Bank'
+      description: 'Price currency (ISO 4217)',
+      example: 'USD'
     },
-    accounts: {
-      description: 'Accounts within this platform',
-      type: 'array',
-      items: {
-        $ref: '#/components/schemas/AccountItemDto'
-      }
+    date: {
+      type: 'string',
+      description: 'Price date (ISO 8601)',
+      example: '2024-06-01'
     },
-    totalBalance: {
+    source: {
       type: 'string',
-      description: 'Total balance across all accounts in platform',
-      example: '100000.00'
+      description: 'Price source',
+      example: 'USER_OVERRIDE',
+      enum: ['USER_OVERRIDE', 'OPENBB_EQUITY', 'OPENBB_CURRENCY']
     }
   },
-  required: ['platformId', 'platformName', 'accounts', 'totalBalance']
+  required: ['amount', 'currency', 'date', 'source']
 } as const;
 
-export const $AccountsSummaryDto = {
+export const $FxRateDto = {
   type: 'object',
   properties: {
-    totalAccounts: {
-      type: 'number',
-      description: 'Total number of accounts'
+    from: {
+      type: 'string',
+      example: 'USD'
     },
-    totalPlatforms: {
-      type: 'number',
-      description: 'Total number of platforms'
-    }
-  },
-  required: ['totalAccounts', 'totalPlatforms']
-} as const;
-
-export const $AccountsResponseDto = {
-  type: 'object',
-  properties: {
-    groups: {
-      description: 'Account groups by platform',
-      type: 'array',
-      items: {
-        $ref: '#/components/schemas/PlatformGroupDto'
-      }
+    to: {
+      type: 'string',
+      example: 'CNY'
     },
-    summary: {
-      description: 'Summary statistics',
-      allOf: [
-        {
-          $ref: '#/components/schemas/AccountsSummaryDto'
-        }
-      ]
+    rate: {
+      type: 'string',
+      description: 'FX rate (Decimal string)',
+      example: '7.2'
+    },
+    date: {
+      type: 'string',
+      description: 'Rate date (ISO 8601)',
+      example: '2024-01-15'
     }
   },
-  required: ['groups', 'summary']
+  required: ['from', 'to', 'rate', 'date']
 } as const;
 
-export const $AccountItemWithAssetClassDto = {
+export const $HoldingPnlRowDto = {
   type: 'object',
   properties: {
-    id: {
+    accountId: {
       type: 'string',
-      description: 'Account ID'
+      description: 'Account UUID',
+      example: 'a1b2c3d4-e5f6-7890-abcd-ef1234567890'
     },
-    name: {
+    accountPath: {
       type: 'string',
-      description: 'Full account name',
-      example: 'Assets:Bank:CMB:Savings'
+      description: 'Full account path',
+      example: 'Assets:US:Broker:AAPL'
     },
-    displayName: {
-      type: 'string',
-      description: 'Display name (last part of account path)',
-      example: 'Savings'
+    accountCcy: {
+      type: 'object',
+      description: 'Account settlement currency (ISO 4217), from cost currency',
+      nullable: true,
+      example: 'USD'
     },
-    balance: {
+    brokerType: {
+      type: 'object',
+      description: 'Broker type derived from Platform.type',
+      nullable: true,
+      example: 'broker'
+    },
+    symbol: {
       type: 'string',
-      description: 'Account balance',
-      example: '50000.00'
+      description: 'Commodity symbol',
+      example: 'AAPL'
     },
-    currency: {
+    chartToken: {
       type: 'string',
-      description: 'Currency code',
-      example: 'CNY'
+      description: 'Chart segment token (libs/common resolver)',
+      example: 'equity',
+      enum: ['equity', 'fund', 'bond', 'cash', 'other']
     },
     assetClass: {
       type: 'string',
-      description: 'Asset class',
-      example: 'LIQUIDITY'
+      example: 'EQUITY'
     },
     assetSubClass: {
-      type: 'string',
-      description: 'Asset sub-class (Prisma-compatible)',
-      example: 'RETIREMENT_ACCOUNT'
+      type: 'object',
+      nullable: true,
+      example: 'STOCK'
     },
-    regionalSubClass: {
+    units: {
       type: 'string',
-      description: 'Regional sub-class (region-specific, for display)',
-      example: 'FOUR_ZERO_ONE_K'
+      description: 'Net held units (Decimal string)',
+      example: '12'
     },
-    riskLevel: {
-      type: 'string',
-      description: 'Risk level',
-      example: 'LOW'
-    }
-  },
-  required: ['id', 'name', 'displayName', 'balance', 'currency', 'assetClass']
-} as const;
-
-export const $AssetClassGroupDto = {
-  type: 'object',
-  properties: {
-    assetClass: {
-      type: 'string',
-      description: 'Asset class name',
-      example: 'LIQUIDITY',
-      enum: [
-        'LIQUIDITY',
-        'EQUITY',
-        'FIXED_INCOME',
-        'PRECIOUS_METALS',
-        'COMMODITY',
-        'INSURANCE',
-        'ALTERNATIVE_INVESTMENT',
-        'PERSONAL_ASSETS',
-        'LIABILITY',
-        'REAL_ESTATE',
-        'INDEX'
+    averageCostPerUnit: {
+      description:
+        'Average cost per unit; null when cost currency conflicts or no cost',
+      nullable: true,
+      allOf: [
+        {
+          $ref: '#/components/schemas/MonetaryDto'
+        }
       ]
     },
-    assetSubClass: {
-      type: 'string',
-      description: 'Asset sub-class name',
-      example: 'DEPOSIT'
+    costBasis: {
+      description: 'Cost basis of held units',
+      nullable: true,
+      allOf: [
+        {
+          $ref: '#/components/schemas/MonetaryDto'
+        }
+      ]
     },
-    accounts: {
-      description: 'Accounts within this asset class',
-      type: 'array',
-      items: {
-        $ref: '#/components/schemas/AccountItemWithAssetClassDto'
-      }
+    marketValue: {
+      description: 'Market value at asOf price',
+      nullable: true,
+      allOf: [
+        {
+          $ref: '#/components/schemas/MonetaryDto'
+        }
+      ]
     },
-    balanceByCurrency: {
-      description: 'Balances grouped by currency',
-      type: 'array',
-      items: {
-        $ref: '#/components/schemas/BalanceByCurrencyDto'
-      }
+    currentPrice: {
+      description: 'Price used for market value',
+      nullable: true,
+      allOf: [
+        {
+          $ref: '#/components/schemas/CurrentPriceDto'
+        }
+      ]
     },
-    convertedBalance: {
-      type: 'string',
-      description: 'Converted balance in base currency',
-      example: '100000.00'
+    unrealizedPnlBase: {
+      type: 'object',
+      description:
+        'Unrealized P&L in base currency (Decimal string); null when any FX/price missing',
+      nullable: true,
+      example: '6000'
+    },
+    unrealizedPnlPct: {
+      type: 'object',
+      description: 'Unrealized P&L % (Decimal string)',
+      nullable: true,
+      example: '25'
+    },
+    costFxRate: {
+      description: 'Historical FX rate applied to cost basis',
+      nullable: true,
+      allOf: [
+        {
+          $ref: '#/components/schemas/FxRateDto'
+        }
+      ]
+    },
+    marketFxRate: {
+      description: 'FX rate applied to market value',
+      nullable: true,
+      allOf: [
+        {
+          $ref: '#/components/schemas/FxRateDto'
+        }
+      ]
+    },
+    pctOfInvestedAssets: {
+      type: 'object',
+      description:
+        'Share of invested assets % (Decimal string); only for invested chartTokens',
+      nullable: true,
+      example: '40'
+    },
+    realizedPnl: {
+      description:
+        'Cumulative realized P&L on sold lots (asOf-date cutoff); null when the method has no applicable sells, a sell lacks a price, or any required FX rate is missing (never-mix). When a sell spans multiple currencies (cross-currency sale), amount and currency reflect the base currency; baseCcyEquivalent is always the authoritative dual-FX figure',
+      nullable: true,
+      allOf: [
+        {
+          $ref: '#/components/schemas/MonetaryDto'
+        }
+      ]
     }
   },
-  required: ['assetClass', 'accounts', 'balanceByCurrency']
+  required: [
+    'accountId',
+    'accountPath',
+    'symbol',
+    'chartToken',
+    'assetClass',
+    'units'
+  ]
 } as const;
 
-export const $AccountExchangeRateWarningDto = {
+export const $HoldingPnlWarningDto = {
   type: 'object',
   properties: {
     type: {
       type: 'string',
       description: 'Warning type',
-      example: 'MISSING_EXCHANGE_RATE'
+      example: 'MISSING_COST_FX_RATE',
+      enum: [
+        'MISSING_COST_FX_RATE',
+        'MISSING_MARKET_FX_RATE',
+        'MISSING_SALE_PRICE',
+        'MISSING_REALIZED_FX_RATE',
+        'OVERSOLD_LOTS',
+        'NO_PRICE',
+        'MIXED_COST_CURRENCY'
+      ]
     },
-    currency: {
-      type: 'string',
-      description: 'Currency without exchange rate',
-      example: 'USD'
+    symbol: {
+      type: 'object',
+      nullable: true
     },
-    accounts: {
-      description: 'Affected account paths',
-      type: 'array',
-      items: {
-        type: 'string'
-      }
+    accountId: {
+      type: 'object',
+      nullable: true
     },
-    totalAmount: {
-      type: 'string',
-      description: 'Total amount in this currency',
-      example: '5000.00'
+    currency: {
+      type: 'object',
+      nullable: true
     }
   },
-  required: ['type', 'currency', 'accounts', 'totalAmount']
+  required: ['type']
 } as const;
 
-export const $AssetClassSummaryDto = {
+export const $HoldingPnlResponseDto = {
   type: 'object',
   properties: {
-    totalAccounts: {
-      type: 'number',
-      description: 'Total number of accounts'
-    },
-    totalAssetClasses: {
-      type: 'number',
-      description: 'Total number of asset classes'
+    asOfDate: {
+      type: 'string',
+      example: '2026-07-08'
     },
     baseCurrency: {
       type: 'string',
-      description: 'Base currency for conversion',
       example: 'CNY'
     },
-    warnings: {
-      description: 'Exchange rate warnings',
-      type: 'array',
-      items: {
-        $ref: '#/components/schemas/AccountExchangeRateWarningDto'
-      }
-    }
-  },
-  required: ['totalAccounts', 'totalAssetClasses', 'baseCurrency']
-} as const;
-
-export const $AssetClassAccountsResponseDto = {
-  type: 'object',
-  properties: {
-    groups: {
-      description: 'Account groups by asset class',
-      type: 'array',
-      items: {
-        $ref: '#/components/schemas/AssetClassGroupDto'
-      }
-    },
-    summary: {
-      description: 'Summary statistics',
-      allOf: [
-        {
-          $ref: '#/components/schemas/AssetClassSummaryDto'
-        }
-      ]
-    }
-  },
-  required: ['groups', 'summary']
-} as const;
-
-export const $CashFlowByCurrencyDto = {
-  type: 'object',
-  properties: {
-    income: {
-      description: 'Income by currency',
-      type: 'array',
-      items: {
-        $ref: '#/components/schemas/BalanceByCurrencyDto'
-      }
+    method: {
+      type: 'string',
+      description:
+        'Realized-P&L lot-matching method (FIFO or average). Unrealized cost basis remains average regardless of this value (#473).',
+      enum: ['average', 'FIFO'],
+      example: 'average'
     },
-    expense: {
-      description: 'Expense by currency',
+    rows: {
       type: 'array',
       items: {
-        $ref: '#/components/schemas/BalanceByCurrencyDto'
+        $ref: '#/components/schemas/HoldingPnlRowDto'
       }
     },
-    netSavings: {
-      description: 'Net savings by currency',
+    warnings: {
       type: 'array',
       items: {
-        $ref: '#/components/schemas/BalanceByCurrencyDto'
+        $ref: '#/components/schemas/HoldingPnlWarningDto'
       }
     }
   },
-  required: ['income', 'expense', 'netSavings']
+  required: ['asOfDate', 'baseCurrency', 'method', 'rows', 'warnings']
 } as const;
 
-export const $ConvertedCashFlowDto = {
+export const $CreateBeanPriceDto = {
   type: 'object',
   properties: {
-    baseCurrency: {
+    currency: {
       type: 'string',
-      description: 'Base currency for conversion',
-      example: 'CNY'
+      description: 'Currency being priced (e.g., USD, AAPL, BTC)',
+      example: 'USD'
     },
-    income: {
+    quoteCurrency: {
       type: 'string',
-      description: 'Converted income',
-      example: '25000.00'
+      description: 'Quote currency (pricing currency, e.g., CNY, EUR)',
+      example: 'CNY'
     },
-    expense: {
-      type: 'string',
-      description: 'Converted expense',
-      example: '18000.00'
+    amount: {
+      type: 'number',
+      description:
+        'Price amount (MUST be >= 0 per Beancount spec, supports up to 15 decimal places). Zero allowed for conversion entries, negative strictly prohibited.',
+      example: 175.5,
+      minimum: 0
     },
-    netSavings: {
+    date: {
       type: 'string',
-      description: 'Converted net savings',
-      example: '7000.00'
+      description: 'Price date (ISO 8601 format)',
+      example: '2024-11-05'
     },
-    exchangeRates: {
+    metadata: {
       type: 'object',
-      description: 'Exchange rates used for conversion',
+      description:
+        'Metadata (validated by Zod schema, max field lengths enforced)',
       example: {
-        USD: '7.200000'
+        source: 'MANUAL',
+        note: 'Bank valuation report',
+        confidence: 0.95
       }
     }
   },
-  required: ['baseCurrency', 'income', 'expense', 'netSavings', 'exchangeRates']
+  required: ['currency', 'quoteCurrency', 'amount', 'date']
 } as const;
 
-export const $CashFlowResponseDto = {
+export const $PriceResponseDto = {
   type: 'object',
   properties: {
-    period: {
+    id: {
       type: 'string',
-      description: 'Period identifier (YYYY-MM)',
-      example: '2024-06'
+      description: 'Unique identifier',
+      example: 'uuid-123-456'
     },
-    income: {
+    userId: {
       type: 'string',
-      description: 'Total income for the period (converted)',
-      example: '25000.00'
+      description: 'User ID (owner of the price)',
+      example: 'user-123'
     },
-    expense: {
+    currency: {
       type: 'string',
-      description: 'Total expenses for the period (converted)',
-      example: '18000.00'
+      description: 'Currency being priced (e.g., USD, AAPL, BTC)',
+      example: 'BTC'
     },
-    netSavings: {
+    quoteCurrency: {
       type: 'string',
-      description: 'Net savings (income - expense, converted)',
-      example: '7000.00'
+      description: 'Quote currency (pricing currency, e.g., USD, CNY)',
+      example: 'USD'
     },
-    savingsRate: {
-      type: 'string',
-      description: 'Savings rate percentage (netSavings / income * 100)',
-      example: '28.00'
+    amount: {
+      type: 'number',
+      description:
+        'Price amount (corresponds to Beancount Amount.number). Supports up to 15 decimal places.',
+      example: 50000
     },
-    currency: {
+    date: {
       type: 'string',
-      description: 'Base currency code',
-      example: 'CNY'
+      description:
+        'Price date (ISO 8601 format). Represents the date this price was valid.',
+      example: '2024-01-01',
+      format: 'date'
     },
-    byCurrency: {
-      description: 'Cash flow grouped by original currency',
-      allOf: [
-        {
-          $ref: '#/components/schemas/CashFlowByCurrencyDto'
-        }
-      ]
+    meta: {
+      type: 'object',
+      description:
+        'Metadata (corresponds to Beancount meta field). Contains source, confidence, note, etc.',
+      example: {
+        source: 'MANUAL',
+        note: 'User-defined price',
+        confidence: 1
+      }
     },
-    converted: {
-      description: 'Converted values in base currency',
-      allOf: [
-        {
-          $ref: '#/components/schemas/ConvertedCashFlowDto'
-        }
-      ]
+    createdAt: {
+      format: 'date-time',
+      type: 'string',
+      description: 'Creation timestamp',
+      example: '2024-11-03T10:00:00Z'
     },
-    warnings: {
-      description: 'Exchange rate warnings',
+    updatedAt: {
+      format: 'date-time',
+      type: 'string',
+      description: 'Last update timestamp',
+      example: '2024-11-03T10:00:00Z'
+    }
+  },
+  required: [
+    'id',
+    'userId',
+    'currency',
+    'quoteCurrency',
+    'amount',
+    'date',
+    'meta',
+    'createdAt',
+    'updatedAt'
+  ]
+} as const;
+
+export const $PriceListResponseDto = {
+  type: 'object',
+  properties: {
+    items: {
+      description: 'List of prices',
       type: 'array',
       items: {
-        $ref: '#/components/schemas/ExchangeRateWarningDto'
+        $ref: '#/components/schemas/PriceResponseDto'
       }
+    },
+    total: {
+      type: 'number',
+      description: 'Total number of prices',
+      example: 42
     }
   },
-  required: [
-    'period',
-    'income',
-    'expense',
-    'netSavings',
-    'savingsRate',
-    'currency'
-  ]
+  required: ['items', 'total']
+} as const;
+
+export const $UpdateBeanPriceDto = {
+  type: 'object',
+  properties: {
+    currency: {
+      type: 'string',
+      description: 'Currency being priced'
+    },
+    quoteCurrency: {
+      type: 'string',
+      description: 'Quote currency (pricing currency)'
+    },
+    amount: {
+      type: 'number',
+      description: 'Price amount (MUST be >= 0 per Beancount spec)',
+      minimum: 0
+    },
+    date: {
+      type: 'string',
+      description: 'Price date (ISO 8601 format)'
+    },
+    metadata: {
+      type: 'object',
+      description: 'Metadata'
+    }
+  }
 } as const;
 
 export const $CurrencyBalanceDto = {