@firela/api-types 0.0.0-canary.f2efa2bf → 0.0.0-canary.f73c3118

package/src/generated/services.gen.ts

@@ -17,6 +17,8 @@ import type {
   AccountControllerCloseResponse,
   AccountControllerReopenData,
   AccountControllerReopenResponse,
+  AccountControllerAddOpeningBalanceData,
+  AccountControllerAddOpeningBalanceResponse,
   AccountStandardsControllerGetTemplatesData,
   AccountStandardsControllerGetTemplatesResponse,
   AccountStandardsControllerGetTemplateMetadataData,
@@ -97,6 +99,48 @@ import type {
   CommodityControllerGetOrCreateResponse,
   CommodityControllerBulkCreateData,
   CommodityControllerBulkCreateResponse,
+  ReportingControllerGetPortfolioTrendsData,
+  ReportingControllerGetPortfolioTrendsResponse,
+  ReportingControllerGetCashFlowTrendsData,
+  ReportingControllerGetCashFlowTrendsResponse,
+  ReportingControllerGenerateSnapshotData,
+  ReportingControllerGenerateSnapshotResponse,
+  ReportingControllerBackfillSnapshotsData,
+  ReportingControllerBackfillSnapshotsResponse,
+  PriceControllerCreateData,
+  PriceControllerCreateResponse,
+  PriceControllerFindAllData,
+  PriceControllerFindAllResponse,
+  PriceControllerFindOneData,
+  PriceControllerFindOneResponse,
+  PriceControllerUpdateData,
+  PriceControllerUpdateResponse,
+  PriceControllerDeleteData,
+  PriceControllerDeleteResponse,
+  PriceControllerBulkCreateData,
+  PriceControllerBulkCreateResponse,
+  UserControllerDeleteOwnUserData,
+  UserControllerDeleteOwnUserResponse,
+  UserControllerGetUserData,
+  UserControllerGetUserResponse,
+  UserControllerSignupUserData,
+  UserControllerSignupUserResponse,
+  UserControllerDeleteUserData,
+  UserControllerDeleteUserResponse,
+  UserControllerGetUserInfoData,
+  UserControllerGetUserInfoResponse,
+  UserControllerUpdateUserSettingData,
+  UserControllerUpdateUserSettingResponse,
+  UserControllerGetAllUserSettingsByPageData,
+  UserControllerGetAllUserSettingsByPageResponse,
+  UserControllerGetAssetLiabilitySummaryResponse,
+  PropertyControllerGetAllResponse,
+  PropertyControllerGetByKeyData,
+  PropertyControllerGetByKeyResponse,
+  PropertyControllerUpdateData,
+  PropertyControllerUpdateResponse,
+  PropertyControllerDeleteData,
+  PropertyControllerDeleteResponse,
   RecurringRuleControllerCreateData,
   RecurringRuleControllerCreateResponse,
   RecurringRuleControllerFindAllData,
@@ -149,28 +193,30 @@ import type {
   TransactionRuleControllerDeleteResponse,
   TransactionRuleControllerTestData,
   TransactionRuleControllerTestResponse,
-  UserControllerDeleteOwnUserData,
-  UserControllerDeleteOwnUserResponse,
-  UserControllerGetUserData,
-  UserControllerGetUserResponse,
-  UserControllerSignupUserData,
-  UserControllerSignupUserResponse,
-  UserControllerDeleteUserData,
-  UserControllerDeleteUserResponse,
-  UserControllerGetUserInfoData,
-  UserControllerGetUserInfoResponse,
-  UserControllerUpdateUserSettingData,
-  UserControllerUpdateUserSettingResponse,
-  UserControllerGetAllUserSettingsByPageData,
-  UserControllerGetAllUserSettingsByPageResponse,
-  UserControllerGetAssetLiabilitySummaryResponse,
-  PropertyControllerGetAllResponse,
-  PropertyControllerGetByKeyData,
-  PropertyControllerGetByKeyResponse,
-  PropertyControllerUpdateData,
-  PropertyControllerUpdateResponse,
-  PropertyControllerDeleteData,
-  PropertyControllerDeleteResponse,
+  CategoryCatalogControllerListData,
+  CategoryCatalogControllerListResponse,
+  EventControllerCreateData,
+  EventControllerCreateResponse,
+  EventControllerFindAllData,
+  EventControllerFindAllResponse,
+  EventControllerFindOneData,
+  EventControllerFindOneResponse,
+  EventControllerUpdateData,
+  EventControllerUpdateResponse,
+  EventControllerDeleteData,
+  EventControllerDeleteResponse,
+  EventControllerGetSliceData,
+  EventControllerGetSliceResponse,
+  OnboardingControllerBootstrapData,
+  OnboardingControllerBootstrapResponse,
+  ReconciliationControllerComputeData,
+  ReconciliationControllerComputeResponse,
+  ReconciliationControllerAssertData,
+  ReconciliationControllerAssertResponse,
+  ReconciliationControllerPadData,
+  ReconciliationControllerPadResponse,
+  ReconciliationControllerHistoryData,
+  ReconciliationControllerHistoryResponse,
   ExportControllerExportBeancountResponse,
   FileImportControllerImportFileData,
   FileImportControllerImportFileResponse,
@@ -184,22 +230,20 @@ import type {
   ImporterConfigControllerUpdateConfigResponse,
   ImporterConfigControllerResetConfigData,
   ImporterConfigControllerResetConfigResponse,
-  PlatformControllerFindAllResponse,
-  PlatformControllerCreateData,
-  PlatformControllerCreateResponse,
-  PlatformControllerGetPlatformListResponse,
-  PlatformControllerMatchPlatformsData,
-  PlatformControllerMatchPlatformsResponse,
-  PlatformControllerUpdateData,
-  PlatformControllerUpdateResponse,
-  PlatformControllerDeleteData,
-  PlatformControllerDeleteResponse,
   ProviderSyncControllerSyncData,
   ProviderSyncControllerSyncResponse,
   ProviderSyncControllerGetSupportedProvidersData,
   ProviderSyncControllerGetSupportedProvidersResponse,
   ProviderSyncControllerIsProviderSupportedData,
   ProviderSyncControllerIsProviderSupportedResponse,
+  ExternalAccountLinkControllerCreateData,
+  ExternalAccountLinkControllerCreateResponse,
+  ExternalAccountLinkControllerFindAllData,
+  ExternalAccountLinkControllerFindAllResponse,
+  ExternalAccountLinkControllerFindOneData,
+  ExternalAccountLinkControllerFindOneResponse,
+  ExternalAccountLinkControllerRemoveData,
+  ExternalAccountLinkControllerRemoveResponse,
   TelemetryControllerReportTelemetryData,
   TelemetryControllerReportTelemetryResponse,
   TelemetryControllerReportCoverageMissData,
@@ -212,35 +256,34 @@ import type {
   NlpControllerClearSessionResponse,
   NlpControllerGetSessionData,
   NlpControllerGetSessionResponse,
+  PlatformControllerFindAllResponse,
+  PlatformControllerCreateData,
+  PlatformControllerCreateResponse,
+  PlatformControllerGetPlatformListData,
+  PlatformControllerGetPlatformListResponse,
+  PlatformControllerMatchPlatformsData,
+  PlatformControllerMatchPlatformsResponse,
+  PlatformControllerGetPlatformStandardsData,
+  PlatformControllerGetPlatformStandardsResponse,
+  PlatformControllerUpdateData,
+  PlatformControllerUpdateResponse,
+  PlatformControllerDeleteData,
+  PlatformControllerDeleteResponse,
   DashboardControllerGetNetWorthData,
   DashboardControllerGetNetWorthResponse,
   DashboardControllerGetAccountsData,
   DashboardControllerGetAccountsResponse,
   DashboardControllerGetCashFlowData,
   DashboardControllerGetCashFlowResponse,
+  DashboardControllerGetExpensesData,
+  DashboardControllerGetExpensesResponse,
   HoldingPnlControllerGetHoldingPnlData,
   HoldingPnlControllerGetHoldingPnlResponse,
-  PriceControllerCreateData,
-  PriceControllerCreateResponse,
-  PriceControllerFindAllData,
-  PriceControllerFindAllResponse,
-  PriceControllerFindOneData,
-  PriceControllerFindOneResponse,
-  PriceControllerUpdateData,
-  PriceControllerUpdateResponse,
-  PriceControllerDeleteData,
-  PriceControllerDeleteResponse,
-  PriceControllerBulkCreateData,
-  PriceControllerBulkCreateResponse,
-  ReportingControllerGetPortfolioTrendsData,
-  ReportingControllerGetPortfolioTrendsResponse,
-  ReportingControllerGenerateSnapshotData,
-  ReportingControllerGenerateSnapshotResponse,
-  ReportingControllerBackfillSnapshotsData,
-  ReportingControllerBackfillSnapshotsResponse,
   ApiKeysControllerCreateApiKeyResponse,
   AuthControllerAccessTokenLoginData,
   AuthControllerAccessTokenLoginResponse,
+  ParserContributionControllerCreateData,
+  ParserContributionControllerCreateResponse,
   CacheControllerFlushCacheResponse,
   ExchangeRateControllerGetExchangeRateData,
   ExchangeRateControllerGetExchangeRateResponse,
@@ -252,15 +295,21 @@ import type {
   HealthControllerResetCircuitBreakerData,
   HealthControllerResetCircuitBreakerResponse,
   HealthControllerGetMetricsResponse,
-  InfoControllerGetInfoResponse
+  InfoControllerGetInfoResponse,
+  SymbolControllerSearchData,
+  SymbolControllerSearchResponse,
+  SymbolControllerGetQuoteData,
+  SymbolControllerGetQuoteResponse
 } from './types.gen';
 
 export class BeanAccountsService {
   /**
+   * Create a new account
+   * Creates a new account (Beancount Open directive)
    * @param data The data for the request.
    * @param data.region Region code for tenant context
    * @param data.requestBody
-   * @returns unknown
+   * @returns AccountResponseDto Account created successfully
    * @throws ApiError
    */
   public static accountControllerCreate(
@@ -273,7 +322,10 @@ export class BeanAccountsService {
         region: data.region
       },
       body: data.requestBody,
-      mediaType: 'application/json'
+      mediaType: 'application/json',
+      errors: {
+        409: 'Account already exists'
+      }
     });
   }
 
@@ -285,7 +337,7 @@ export class BeanAccountsService {
    * @param data.type Filter by account type
    * @param data.status Filter by status
    * @param data.isCustom Filter by custom (user-created) accounts only
-   * @param data.search Search term for path or i18nKey
+   * @param data.search Search term for account path
    * @param data.limit Maximum number of results
    * @param data.offset Number of results to skip
    * @returns AccountListResponseDto Accounts retrieved successfully
@@ -337,11 +389,13 @@ export class BeanAccountsService {
   }
 
   /**
+   * Update account
+   * Updates account metadata (path cannot be changed)
    * @param data The data for the request.
-   * @param data.id
+   * @param data.id Account UUID
    * @param data.region Region code for tenant context
    * @param data.requestBody
-   * @returns unknown
+   * @returns AccountResponseDto Account updated successfully
    * @throws ApiError
    */
   public static accountControllerUpdate(
@@ -355,15 +409,20 @@ export class BeanAccountsService {
         region: data.region
       },
       body: data.requestBody,
-      mediaType: 'application/json'
+      mediaType: 'application/json',
+      errors: {
+        404: 'Account not found'
+      }
     });
   }
 
   /**
+   * Delete account
+   * Deletes an account (only if no active transactions; voided/superseded residual postings are cleaned up)
    * @param data The data for the request.
-   * @param data.id
+   * @param data.id Account UUID
    * @param data.region Region code for tenant context
-   * @returns unknown
+   * @returns void Account deleted successfully
    * @throws ApiError
    */
   public static accountControllerDelete(
@@ -375,16 +434,22 @@ export class BeanAccountsService {
       path: {
         id: data.id,
         region: data.region
+      },
+      errors: {
+        404: 'Account not found',
+        409: 'Account has active transactions and cannot be deleted'
       }
     });
   }
 
   /**
+   * Close account
+   * Closes an account (Beancount Close directive)
    * @param data The data for the request.
-   * @param data.id
+   * @param data.id Account UUID
    * @param data.region Region code for tenant context
    * @param data.requestBody
-   * @returns unknown
+   * @returns AccountResponseDto Account closed successfully
    * @throws ApiError
    */
   public static accountControllerClose(
@@ -398,16 +463,22 @@ export class BeanAccountsService {
         region: data.region
       },
       body: data.requestBody,
-      mediaType: 'application/json'
+      mediaType: 'application/json',
+      errors: {
+        400: 'Account is already closed',
+        404: 'Account not found'
+      }
     });
   }
 
   /**
+   * Reopen account
+   * Reopens a previously closed account
    * @param data The data for the request.
-   * @param data.id
+   * @param data.id Account UUID
    * @param data.region Region code for tenant context
    * @param data.requestBody
-   * @returns unknown
+   * @returns AccountResponseDto Account reopened successfully
    * @throws ApiError
    */
   public static accountControllerReopen(
@@ -421,7 +492,40 @@ export class BeanAccountsService {
         region: data.region
       },
       body: data.requestBody,
-      mediaType: 'application/json'
+      mediaType: 'application/json',
+      errors: {
+        400: 'Account is not closed',
+        404: 'Account not found'
+      }
+    });
+  }
+
+  /**
+   * Post an opening-balance transaction
+   * Posts a double-entry opening-balance transaction against Equity:Opening-Balances for an existing Assets/Liabilities account. At most one active opening balance per account.
+   * @param data The data for the request.
+   * @param data.id Account UUID
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns OpeningBalanceResultDto Opening-balance transaction created
+   * @throws ApiError
+   */
+  public static accountControllerAddOpeningBalance(
+    data: AccountControllerAddOpeningBalanceData
+  ): CancelablePromise<AccountControllerAddOpeningBalanceResponse> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/{region}/bean/accounts/{id}/opening-balance',
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        404: 'Account not found',
+        409: 'An opening balance already exists for this account'
+      }
     });
   }
 }
@@ -429,11 +533,11 @@ export class BeanAccountsService {
 export class BeanAccountStandardsService {
   /**
    * Get account templates
-   * Returns predefined account templates for a region. Supports filtering by account type and search term.
+   * Returns predefined account templates for a region. Supports filtering by account type and search term. Not-yet-open region codes return the universal-only catalog (#759).
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
+   * @param data.region Region code (any ISO alpha-2; not-yet-open codes return the universal-only catalog)
    * @param data.type Filter by account type
-   * @param data.search Search term for path or description
+   * @param data.search Search term for path, description, aliases, or localized display name
    * @returns AccountStandardListResponseDto Account templates retrieved successfully
    * @throws ApiError
    */
@@ -455,9 +559,9 @@ export class BeanAccountStandardsService {
 
   /**
    * Get template metadata for an account path
-   * Returns extendable status and root type for a template path.
+   * Returns root type for a template path.
    * @param data The data for the request.
-   * @param data.region Region code for tenant context
+   * @param data.region Region code for tenant context. Not-yet-open codes degrade to the universal-only catalog (#759)
    * @param data.path Account path to check
    * @returns TemplateMetadataResponseDto Template metadata retrieved successfully
    * @throws ApiError
@@ -479,9 +583,9 @@ export class BeanAccountStandardsService {
 
   /**
    * Get available regions with hierarchy
-   * Returns supported regions with inheritance metadata
+   * Returns the full region catalog (every ISO 3166-1 entry) with an 'open' flag and inheritance metadata (#759)
    * @param data The data for the request.
-   * @param data.region Region code for tenant context
+   * @param data.region Region code for tenant context. Not-yet-open codes degrade to the universal-only catalog (#759)
    * @returns RegionsMetadataResponseDto Regions metadata retrieved successfully
    * @throws ApiError
    */
@@ -538,9 +642,11 @@ export class BeanTransactionsService {
    * @param data.offset Number of items to skip (default: 0)
    * @param data.dateFrom Filter by start date (inclusive), format: YYYY-MM-DD
    * @param data.dateTo Filter by end date (inclusive), format: YYYY-MM-DD
-   * @param data.status Filter by transaction status
+   * @param data.status Filter by transaction status: single value, comma-separated multi-value (e.g. VOIDED,SUPERSEDED), or ALL to include audit rows. Defaults to ACTIVE-only (ADR-0128; previously unfiltered — breaking change).
    * @param data.search Search in narration and payee fields (max 200 chars)
    * @param data.accountId Filter by account ID (transactions with postings to this account)
+   * @param data.category Filter by ADR-0075 functional category (Group segment); matches any posting to an account whose derived Group segment equals this value. Must be accompanied by flow (ADR-0126).
+   * @param data.flow Required when category is present (400 otherwise) and vice versa (ADR-0126). Restricts the category account set to the flow root (income → Income:, expense → Expenses:) and drives the per-leg sign normalization of row viewpointAmount and the summary. OpenAPI cannot express conditional requiredness — the pairing is enforced at runtime.
    * @returns TransactionListResponseDto Transaction list
    * @throws ApiError
    */
@@ -560,7 +666,9 @@ export class BeanTransactionsService {
         dateTo: data.dateTo,
         status: data.status,
         search: data.search,
-        accountId: data.accountId
+        accountId: data.accountId,
+        category: data.category,
+        flow: data.flow
       },
       errors: {
         400: 'Validation failed',
@@ -748,7 +856,7 @@ export class BeanBalancesService {
    * Query account balance
    * Calculate account balance at a specific date for a single currency
    * @param data The data for the request.
-   * @param data.account Account name (e.g., "Assets:Bank:Checking")
+   * @param data.account Account name (e.g., "Assets:Checking")
    * @param data.region Region code for tenant context
    * @param data.date Date to calculate balance at (ISO 8601 format)
    * @param data.currency Currency to query (e.g., "USD", "CNY")
@@ -1273,7 +1381,7 @@ export class AdminPayeeProfilesService {
    * Removes verification status by setting verifiedAt to null.
    * @param data The data for the request.
    * @param data.id Payee profile ID (UUID)
-   * @returns PayeeProfileResponseDto Payee profile unverified successfully
+   * @returns void Payee profile unverified successfully
    * @throws ApiError
    */
   public static payeeProfileAdminControllerUnverify(
@@ -1469,96 +1577,675 @@ export class BeanCommoditiesService {
   }
 }
 
-export class RecurringRulesService {
+export class ReportingService {
   /**
-   * Create a new recurring rule
-   * Creates a new recurring transaction rule for the authenticated user
+   * Get portfolio value trends
+   *
+   * Returns time series data of portfolio net worth.
+   *
+   * **Multi-currency Support:**
+   * - `series[].byCurrency` - Currency breakdown for each data point
+   * - `byCurrency` - Separate time series grouped by currency
+   * - `warnings` - Exchange rate warnings if conversion failed
+   *
+   * **Parameters:**
+   * - `period`: Time period (1m, 3m, 6m, 1y)
+   * - `granularity`: Data granularity (day, week, month)
+   *
    * @param data The data for the request.
    * @param data.region Region code for tenant context
-   * @param data.requestBody
-   * @returns RecurringRuleResponseDto Rule created successfully
+   * @param data.period Time period
+   * @param data.granularity Data granularity
+   * @returns PortfolioTrendsResponseDto Trends retrieved successfully
    * @throws ApiError
    */
-  public static recurringRuleControllerCreate(
-    data: RecurringRuleControllerCreateData
-  ): CancelablePromise<RecurringRuleControllerCreateResponse> {
+  public static reportingControllerGetPortfolioTrends(
+    data: ReportingControllerGetPortfolioTrendsData
+  ): CancelablePromise<ReportingControllerGetPortfolioTrendsResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/{region}/bean/recurring-rules',
+      method: 'GET',
+      url: '/api/v1/{region}/reporting/portfolio/trends',
       path: {
         region: data.region
       },
-      body: data.requestBody,
-      mediaType: 'application/json',
+      query: {
+        period: data.period,
+        granularity: data.granularity
+      },
       errors: {
-        400: 'Invalid input data (e.g., autoCreate without accounts)',
-        409: 'Rule with same name already exists'
+        401: 'User not authenticated'
       }
     });
   }
 
   /**
-   * List recurring rules
-   * Returns all recurring rules for the authenticated user with optional filtering
+   * Get cash-flow trends
+   *
+   * Monthly income / expense / netSavings over a fixed N-month window
+   * (current month + N−1 prior). Missing months are zero-filled (flow metric).
+   *
+   * **Parameters:**
+   * - `period`: 1m | 3m | 6m | 1y (default 6m)
+   * - `granularity`: accepted for API symmetry; v1 returns month buckets
+   *
    * @param data The data for the request.
    * @param data.region Region code for tenant context
-   * @param data.isActive Filter by active status
-   * @param data.frequency Filter by frequency (WEEKLY, MONTHLY, etc.)
-   * @param data.hasAutoCreate Filter by autoCreate enabled
-   * @returns RecurringRuleResponseDto Rules retrieved successfully
+   * @param data.period Time period
+   * @param data.granularity Data granularity (accepted for API symmetry; v1 returns month buckets)
+   * @returns CashFlowTrendsResponseDto Cash-flow trends retrieved successfully
    * @throws ApiError
    */
-  public static recurringRuleControllerFindAll(
-    data: RecurringRuleControllerFindAllData
-  ): CancelablePromise<RecurringRuleControllerFindAllResponse> {
+  public static reportingControllerGetCashFlowTrends(
+    data: ReportingControllerGetCashFlowTrendsData
+  ): CancelablePromise<ReportingControllerGetCashFlowTrendsResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/{region}/bean/recurring-rules',
+      url: '/api/v1/{region}/reporting/cash-flow/trends',
       path: {
         region: data.region
       },
       query: {
-        isActive: data.isActive,
-        frequency: data.frequency,
-        hasAutoCreate: data.hasAutoCreate
+        period: data.period,
+        granularity: data.granularity
+      },
+      errors: {
+        401: 'User not authenticated'
       }
     });
   }
 
   /**
-   * Create recurring rule from transaction
-   * Auto-creates a recurring rule using transaction data. User only confirms frequency.
+   * Generate portfolio snapshot
+   *
+   * Manually generate a portfolio snapshot for a specific date.
+   *
+   * **Multi-currency Support:**
+   * - Fetches balances grouped by currency
+   * - Uses user's baseCurrency setting for conversion
+   * - Stores exchange rates and warnings
+   *
+   * **Use Cases:**
+   * - Testing snapshot generation
+   * - Force regeneration after data correction
+   * - Initial setup for new users
+   *
    * @param data The data for the request.
-   * @param data.transactionId Source transaction ID
    * @param data.region Region code for tenant context
-   * @param data.requestBody
-   * @returns RecurringRuleResponseDto Rule created successfully
+   * @param data.requestBody Optional date (defaults to today)
+   * @returns GenerateSnapshotResponse Snapshot generated successfully
    * @throws ApiError
    */
-  public static recurringRuleControllerCreateFromTransaction(
-    data: RecurringRuleControllerCreateFromTransactionData
-  ): CancelablePromise<RecurringRuleControllerCreateFromTransactionResponse> {
+  public static reportingControllerGenerateSnapshot(
+    data: ReportingControllerGenerateSnapshotData
+  ): CancelablePromise<ReportingControllerGenerateSnapshotResponse> {
     return __request(OpenAPI, {
       method: 'POST',
-      url: '/api/v1/{region}/bean/recurring-rules/from-transaction/{transactionId}',
+      url: '/api/v1/{region}/reporting/snapshots/generate',
       path: {
-        transactionId: data.transactionId,
         region: data.region
       },
       body: data.requestBody,
       mediaType: 'application/json',
       errors: {
-        404: 'Transaction not found',
-        409: 'Rule with same name already exists or transaction already linked'
+        400: 'Invalid date format',
+        401: 'User not authenticated'
       }
     });
   }
 
   /**
-   * Get recurring rule by ID
-   * Returns a specific recurring rule with its details
-   * @param data The data for the request.
-   * @param data.id Rule ID
+   * Backfill portfolio snapshots
+   *
+   * Generate snapshots for a date range (historical data backfill).
+   *
+   * **Multi-currency Support:**
+   * - Each snapshot includes multi-currency data
+   * - Uses exchange rates available at generation time
+   * - Warnings stored for missing exchange rates
+   *
+   * **Best Practices:**
+   * - Use for initial setup after account configuration
+   * - Run during low-traffic periods for large date ranges
+   * - Existing snapshots are skipped (not regenerated)
+   *
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns BackfillSnapshotsResponse Backfill completed successfully
+   * @throws ApiError
+   */
+  public static reportingControllerBackfillSnapshots(
+    data: ReportingControllerBackfillSnapshotsData
+  ): CancelablePromise<ReportingControllerBackfillSnapshotsResponse> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/{region}/reporting/snapshots/backfill',
+      path: {
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: 'Invalid date format or range',
+        401: 'User not authenticated',
+        409: 'Backfill already in progress for this user'
+      }
+    });
+  }
+}
+
+export class BeanPricesService {
+  /**
+   * Create a new price
+   * Creates a new price entry for the authenticated user
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns PriceResponseDto Price created successfully
+   * @throws ApiError
+   */
+  public static priceControllerCreate(
+    data: PriceControllerCreateData
+  ): CancelablePromise<PriceControllerCreateResponse> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/{region}/bean/prices',
+      path: {
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        404: 'Currency or quoteCurrency commodity not found',
+        409: 'Price already exists for this currency pair and date'
+      }
+    });
+  }
+
+  /**
+   * List user prices
+   * Returns all price entries for the authenticated user with optional filtering
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @param data.currency Filter by currency (e.g., BTC, AAPL, USD)
+   * @param data.quoteCurrency Filter by quote currency (pricing currency, e.g., USD, CNY)
+   * @param data.dateFrom Filter prices from this date (ISO 8601 format)
+   * @param data.dateTo Filter prices to this date (ISO 8601 format)
+   * @param data.search Search term for currency or quoteCurrency (case-insensitive partial match)
+   * @param data.page Page number for pagination (default: 1)
+   * @param data.limit Number of items per page (default: 20, max: 100)
+   * @returns PriceListResponseDto Prices retrieved successfully
+   * @throws ApiError
+   */
+  public static priceControllerFindAll(
+    data: PriceControllerFindAllData
+  ): CancelablePromise<PriceControllerFindAllResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/bean/prices',
+      path: {
+        region: data.region
+      },
+      query: {
+        currency: data.currency,
+        quoteCurrency: data.quoteCurrency,
+        dateFrom: data.dateFrom,
+        dateTo: data.dateTo,
+        search: data.search,
+        page: data.page,
+        limit: data.limit
+      }
+    });
+  }
+
+  /**
+   * Get price by ID
+   * Returns a single price entry by its ID
+   * @param data The data for the request.
+   * @param data.id Price ID
+   * @param data.region Region code for tenant context
+   * @returns PriceResponseDto Price retrieved successfully
+   * @throws ApiError
+   */
+  public static priceControllerFindOne(
+    data: PriceControllerFindOneData
+  ): CancelablePromise<PriceControllerFindOneResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/bean/prices/{id}',
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      errors: {
+        404: 'Price not found'
+      }
+    });
+  }
+
+  /**
+   * Update a price
+   * Updates an existing price entry
+   * @param data The data for the request.
+   * @param data.id Price ID
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns PriceResponseDto Price updated successfully
+   * @throws ApiError
+   */
+  public static priceControllerUpdate(
+    data: PriceControllerUpdateData
+  ): CancelablePromise<PriceControllerUpdateResponse> {
+    return __request(OpenAPI, {
+      method: 'PUT',
+      url: '/api/v1/{region}/bean/prices/{id}',
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        404: 'Price not found',
+        409: 'Updated price conflicts with existing price'
+      }
+    });
+  }
+
+  /**
+   * Delete a price
+   * Deletes a price entry (hard delete)
+   * @param data The data for the request.
+   * @param data.id Price ID
+   * @param data.region Region code for tenant context
+   * @returns void Price deleted successfully
+   * @throws ApiError
+   */
+  public static priceControllerDelete(
+    data: PriceControllerDeleteData
+  ): CancelablePromise<PriceControllerDeleteResponse> {
+    return __request(OpenAPI, {
+      method: 'DELETE',
+      url: '/api/v1/{region}/bean/prices/{id}',
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      errors: {
+        404: 'Price not found'
+      }
+    });
+  }
+
+  /**
+   * Bulk create prices
+   * Creates multiple price entries at once (skips duplicates)
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns PriceResponseDto Prices created successfully
+   * @throws ApiError
+   */
+  public static priceControllerBulkCreate(
+    data: PriceControllerBulkCreateData
+  ): CancelablePromise<PriceControllerBulkCreateResponse> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/{region}/bean/prices/bulk',
+      path: {
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json'
+    });
+  }
+}
+
+export class UsersService {
+  /**
+   * Delete own user account
+   * @param data The data for the request.
+   * @param data.requestBody
+   * @returns void User deleted successfully
+   * @throws ApiError
+   */
+  public static userControllerDeleteOwnUser(
+    data: UserControllerDeleteOwnUserData
+  ): CancelablePromise<UserControllerDeleteOwnUserResponse> {
+    return __request(OpenAPI, {
+      method: 'DELETE',
+      url: '/api/v1/users',
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        403: 'Invalid access token'
+      }
+    });
+  }
+
+  /**
+   * Get current authenticated user
+   * @param data The data for the request.
+   * @param data.acceptLanguage
+   * @returns UserResponseDto User retrieved successfully
+   * @throws ApiError
+   */
+  public static userControllerGetUser(
+    data: UserControllerGetUserData
+  ): CancelablePromise<UserControllerGetUserResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/users',
+      headers: {
+        'accept-language': data.acceptLanguage
+      }
+    });
+  }
+
+  /**
+   * Sign up new user
+   * Create a new account with auto-generated access token. Protected by Cloudflare Turnstile to prevent automated signup (when enabled).
+   * @param data The data for the request.
+   * @param data.requestBody
+   * @returns SignupResponseDto User created successfully
+   * @throws ApiError
+   */
+  public static userControllerSignupUser(
+    data: UserControllerSignupUserData
+  ): CancelablePromise<UserControllerSignupUserResponse> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/users',
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: 'Invalid Turnstile token (when Turnstile is enabled)',
+        403: 'User signup is disabled'
+      }
+    });
+  }
+
+  /**
+   * Delete user by ID (admin only)
+   * @param data The data for the request.
+   * @param data.id User ID to delete
+   * @returns void User deleted successfully
+   * @throws ApiError
+   */
+  public static userControllerDeleteUser(
+    data: UserControllerDeleteUserData
+  ): CancelablePromise<UserControllerDeleteUserResponse> {
+    return __request(OpenAPI, {
+      method: 'DELETE',
+      url: '/api/v1/users/{id}',
+      path: {
+        id: data.id
+      },
+      errors: {
+        403: 'Cannot delete own account or insufficient permissions'
+      }
+    });
+  }
+
+  /**
+   * Get user info by user ID
+   * @param data The data for the request.
+   * @param data.id User ID
+   * @returns unknown User info retrieved successfully
+   * @throws ApiError
+   */
+  public static userControllerGetUserInfo(
+    data: UserControllerGetUserInfoData
+  ): CancelablePromise<UserControllerGetUserInfoResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/users/{id}/info',
+      path: {
+        id: data.id
+      },
+      errors: {
+        403: 'Cannot access other user info without admin permission'
+      }
+    });
+  }
+
+  /**
+   * Update user settings
+   * @param data The data for the request.
+   * @param data.requestBody
+   * @returns unknown Settings updated successfully
+   * @throws ApiError
+   */
+  public static userControllerUpdateUserSetting(
+    data: UserControllerUpdateUserSettingData
+  ): CancelablePromise<UserControllerUpdateUserSettingResponse> {
+    return __request(OpenAPI, {
+      method: 'PUT',
+      url: '/api/v1/users/setting',
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        403: 'Insufficient permissions'
+      }
+    });
+  }
+
+  /**
+   * Get all user settings paginated (admin only)
+   * @param data The data for the request.
+   * @param data.pageNo Page number
+   * @param data.pageSize Page size
+   * @returns unknown Settings list retrieved successfully
+   * @throws ApiError
+   */
+  public static userControllerGetAllUserSettingsByPage(
+    data: UserControllerGetAllUserSettingsByPageData
+  ): CancelablePromise<UserControllerGetAllUserSettingsByPageResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/users/settings-by-page',
+      query: {
+        pageNo: data.pageNo,
+        pageSize: data.pageSize
+      }
+    });
+  }
+
+  /**
+   * Get asset and liability summary for current user
+   * @returns unknown Summary retrieved successfully
+   * @throws ApiError
+   */
+  public static userControllerGetAssetLiabilitySummary(): CancelablePromise<UserControllerGetAssetLiabilitySummaryResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/users/asset-liability-summary'
+    });
+  }
+}
+
+export class PropertiesService {
+  /**
+   * Get all system properties
+   * @returns unknown Properties retrieved successfully
+   * @throws ApiError
+   */
+  public static propertyControllerGetAll(): CancelablePromise<PropertyControllerGetAllResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/admin/properties',
+      errors: {
+        401: 'Unauthorized',
+        403: 'Forbidden - insufficient permissions'
+      }
+    });
+  }
+
+  /**
+   * Get property by key
+   * @param data The data for the request.
+   * @param data.key Property key
+   * @returns unknown Property retrieved successfully
+   * @throws ApiError
+   */
+  public static propertyControllerGetByKey(
+    data: PropertyControllerGetByKeyData
+  ): CancelablePromise<PropertyControllerGetByKeyResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/admin/properties/{key}',
+      path: {
+        key: data.key
+      },
+      errors: {
+        401: 'Unauthorized',
+        403: 'Forbidden - insufficient permissions',
+        404: 'Property not found'
+      }
+    });
+  }
+
+  /**
+   * Update a system property
+   * @param data The data for the request.
+   * @param data.key Property key
+   * @param data.requestBody
+   * @returns unknown Property updated successfully
+   * @throws ApiError
+   */
+  public static propertyControllerUpdate(
+    data: PropertyControllerUpdateData
+  ): CancelablePromise<PropertyControllerUpdateResponse> {
+    return __request(OpenAPI, {
+      method: 'PUT',
+      url: '/api/v1/admin/properties/{key}',
+      path: {
+        key: data.key
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        401: 'Unauthorized',
+        403: 'Forbidden - insufficient permissions'
+      }
+    });
+  }
+
+  /**
+   * Delete a system property
+   * @param data The data for the request.
+   * @param data.key Property key
+   * @returns void Property deleted successfully
+   * @throws ApiError
+   */
+  public static propertyControllerDelete(
+    data: PropertyControllerDeleteData
+  ): CancelablePromise<PropertyControllerDeleteResponse> {
+    return __request(OpenAPI, {
+      method: 'DELETE',
+      url: '/api/v1/admin/properties/{key}',
+      path: {
+        key: data.key
+      },
+      errors: {
+        401: 'Unauthorized',
+        403: 'Forbidden - insufficient permissions',
+        404: 'Property not found'
+      }
+    });
+  }
+}
+
+export class RecurringRulesService {
+  /**
+   * Create a new recurring rule
+   * Creates a new recurring transaction rule for the authenticated user
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns RecurringRuleResponseDto Rule created successfully
+   * @throws ApiError
+   */
+  public static recurringRuleControllerCreate(
+    data: RecurringRuleControllerCreateData
+  ): CancelablePromise<RecurringRuleControllerCreateResponse> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/{region}/bean/recurring-rules',
+      path: {
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: 'Invalid input data (e.g., autoCreate without accounts)',
+        409: 'Rule with same name already exists'
+      }
+    });
+  }
+
+  /**
+   * List recurring rules
+   * Returns all recurring rules for the authenticated user with optional filtering
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @param data.isActive Filter by active status
+   * @param data.frequency Filter by frequency (WEEKLY, MONTHLY, etc.)
+   * @param data.hasAutoCreate Filter by autoCreate enabled
+   * @returns RecurringRuleResponseDto Rules retrieved successfully
+   * @throws ApiError
+   */
+  public static recurringRuleControllerFindAll(
+    data: RecurringRuleControllerFindAllData
+  ): CancelablePromise<RecurringRuleControllerFindAllResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/bean/recurring-rules',
+      path: {
+        region: data.region
+      },
+      query: {
+        isActive: data.isActive,
+        frequency: data.frequency,
+        hasAutoCreate: data.hasAutoCreate
+      }
+    });
+  }
+
+  /**
+   * Create recurring rule from transaction
+   * Auto-creates a recurring rule using transaction data. User only confirms frequency.
+   * @param data The data for the request.
+   * @param data.transactionId Source transaction ID
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns RecurringRuleResponseDto Rule created successfully
+   * @throws ApiError
+   */
+  public static recurringRuleControllerCreateFromTransaction(
+    data: RecurringRuleControllerCreateFromTransactionData
+  ): CancelablePromise<RecurringRuleControllerCreateFromTransactionResponse> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/{region}/bean/recurring-rules/from-transaction/{transactionId}',
+      path: {
+        transactionId: data.transactionId,
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        404: 'Transaction not found',
+        409: 'Rule with same name already exists or transaction already linked'
+      }
+    });
+  }
+
+  /**
+   * Get recurring rule by ID
+   * Returns a specific recurring rule with its details
+   * @param data The data for the request.
+   * @param data.id Rule ID
    * @param data.region Region code for tenant context
    * @returns RecurringRuleResponseDto Rule retrieved successfully
    * @throws ApiError
@@ -1767,7 +2454,7 @@ export class ExpectedTransactionsService {
    * @param data The data for the request.
    * @param data.id Expected transaction ID
    * @param data.region Region code for tenant context
-   * @returns ExpectedTransactionResponseDto Skip undone successfully
+   * @returns void Skip undone successfully
    * @throws ApiError
    */
   public static expectedTransactionControllerUndoSkip(
@@ -1823,7 +2510,7 @@ export class ExpectedTransactionsService {
    * @param data The data for the request.
    * @param data.id Expected transaction ID
    * @param data.region Region code for tenant context
-   * @returns unknown Match removed successfully
+   * @returns void Match removed successfully
    * @throws ApiError
    */
   public static expectedTransactionControllerUnmatch(
@@ -2177,256 +2864,337 @@ export class BeanTransactionRulesService {
   }
 }
 
-export class UsersService {
+export class BeanCategoryCatalogService {
   /**
-   * Delete own user account
+   * List category catalog for a region
+   * Returns the region-scoped category slugs (expense/income/investment/banking/transfer/payment) for the NLP result picker. CN-exclusive payment instruments (huabei/baitiao) appear only under /cn.
    * @param data The data for the request.
-   * @param data.requestBody
-   * @returns void User deleted successfully
+   * @param data.region Region code for tenant context
+   * @param data.scenario Filter by scenario
+   * @param data.routeBearing Filter by routeBearing (entity-router route() consumes it)
+   * @returns CategoryCatalogListResponseDto Category catalog retrieved successfully
    * @throws ApiError
    */
-  public static userControllerDeleteOwnUser(
-    data: UserControllerDeleteOwnUserData
-  ): CancelablePromise<UserControllerDeleteOwnUserResponse> {
+  public static categoryCatalogControllerList(
+    data: CategoryCatalogControllerListData
+  ): CancelablePromise<CategoryCatalogControllerListResponse> {
     return __request(OpenAPI, {
-      method: 'DELETE',
-      url: '/api/v1/users',
-      body: data.requestBody,
-      mediaType: 'application/json',
-      errors: {
-        403: 'Invalid access token'
+      method: 'GET',
+      url: '/api/v1/{region}/bean/categories',
+      path: {
+        region: data.region
+      },
+      query: {
+        scenario: data.scenario,
+        routeBearing: data.routeBearing
       }
     });
   }
+}
 
+export class LifeEventsService {
   /**
-   * Get current authenticated user
+   * Create a new life event
+   * Creates a new life event entry for the authenticated user. Returns ETag header carrying the row updatedAt.
    * @param data The data for the request.
-   * @param data.acceptLanguage
-   * @returns unknown User retrieved successfully
+   * @param data.region Region code for tenant context (decorative for life events)
+   * @param data.requestBody
+   * @returns EventResponseDto Life event created successfully
    * @throws ApiError
    */
-  public static userControllerGetUser(
-    data: UserControllerGetUserData
-  ): CancelablePromise<UserControllerGetUserResponse> {
+  public static eventControllerCreate(
+    data: EventControllerCreateData
+  ): CancelablePromise<EventControllerCreateResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/users',
-      headers: {
-        'accept-language': data.acceptLanguage
+      method: 'POST',
+      url: '/api/v1/{region}/bean/events',
+      path: {
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        409: 'Life event already exists for this (userId, type, date) combination'
       }
     });
   }
 
   /**
-   * Sign up new user
-   * Create a new account with auto-generated access token. Protected by Cloudflare Turnstile to prevent automated signup (when enabled).
+   * List user life events
+   * Returns life events for the authenticated user with optional filtering by type, description search, and date range.
    * @param data The data for the request.
-   * @param data.requestBody
-   * @returns unknown User created successfully
+   * @param data.region Region code for tenant context (decorative for life events)
+   * @param data.type Filter by life event type (exact match)
+   * @param data.q Search term for description (case-insensitive partial match)
+   * @param data.from Filter life events from this date (ISO 8601 format)
+   * @param data.to Filter life events to this date (ISO 8601 format)
+   * @param data.page Page number for pagination (default: 1)
+   * @param data.limit Number of items per page (default: 20, max: 100)
+   * @returns EventListResponseDto Life events retrieved successfully
    * @throws ApiError
    */
-  public static userControllerSignupUser(
-    data: UserControllerSignupUserData
-  ): CancelablePromise<UserControllerSignupUserResponse> {
+  public static eventControllerFindAll(
+    data: EventControllerFindAllData
+  ): CancelablePromise<EventControllerFindAllResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/users',
-      body: data.requestBody,
-      mediaType: 'application/json',
-      errors: {
-        400: 'Invalid Turnstile token (when Turnstile is enabled)',
-        403: 'User signup is disabled'
+      method: 'GET',
+      url: '/api/v1/{region}/bean/events',
+      path: {
+        region: data.region
+      },
+      query: {
+        type: data.type,
+        q: data.q,
+        from: data.from,
+        to: data.to,
+        page: data.page,
+        limit: data.limit
       }
     });
   }
 
   /**
-   * Delete user by ID (admin only)
+   * Get life event by ID
+   * Returns a single life event by its ID. Returns ETag header.
    * @param data The data for the request.
-   * @param data.id User ID to delete
-   * @returns void User deleted successfully
+   * @param data.id Life event ID
+   * @param data.region Region code for tenant context (decorative for life events)
+   * @returns EventResponseDto Life event retrieved successfully
    * @throws ApiError
    */
-  public static userControllerDeleteUser(
-    data: UserControllerDeleteUserData
-  ): CancelablePromise<UserControllerDeleteUserResponse> {
+  public static eventControllerFindOne(
+    data: EventControllerFindOneData
+  ): CancelablePromise<EventControllerFindOneResponse> {
     return __request(OpenAPI, {
-      method: 'DELETE',
-      url: '/api/v1/users/{id}',
+      method: 'GET',
+      url: '/api/v1/{region}/bean/events/{id}',
       path: {
-        id: data.id
+        id: data.id,
+        region: data.region
       },
       errors: {
-        403: 'Cannot delete own account or insufficient permissions'
+        404: 'Life event not found'
       }
     });
   }
 
   /**
-   * Get user info by user ID
+   * Update a life event
+   * Updates an existing life event. If If-Match header is provided, performs optimistic concurrency check; mismatched updatedAt returns 412.
    * @param data The data for the request.
-   * @param data.id User ID
-   * @returns unknown User info retrieved successfully
+   * @param data.id Life event ID
+   * @param data.region Region code for tenant context (decorative for life events)
+   * @param data.requestBody
+   * @returns EventResponseDto Life event updated successfully
    * @throws ApiError
    */
-  public static userControllerGetUserInfo(
-    data: UserControllerGetUserInfoData
-  ): CancelablePromise<UserControllerGetUserInfoResponse> {
+  public static eventControllerUpdate(
+    data: EventControllerUpdateData
+  ): CancelablePromise<EventControllerUpdateResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/users/{id}/info',
+      method: 'PUT',
+      url: '/api/v1/{region}/bean/events/{id}',
       path: {
-        id: data.id
+        id: data.id,
+        region: data.region
       },
+      body: data.requestBody,
+      mediaType: 'application/json',
       errors: {
-        403: 'Cannot access other user info without admin permission'
+        400: 'If-Match header is not a valid ISO 8601 date',
+        404: 'Life event not found',
+        409: 'Updated event conflicts with an existing (userId, type, date) combination',
+        412: 'If-Match precondition failed (updatedAt mismatch)'
       }
     });
   }
 
   /**
-   * Update user settings
+   * Delete a life event
+   * Deletes a life event entry (hard delete). Returns 204.
    * @param data The data for the request.
-   * @param data.requestBody
-   * @returns unknown Settings updated successfully
+   * @param data.id Life event ID
+   * @param data.region Region code for tenant context (decorative for life events)
+   * @returns void Life event deleted successfully
    * @throws ApiError
    */
-  public static userControllerUpdateUserSetting(
-    data: UserControllerUpdateUserSettingData
-  ): CancelablePromise<UserControllerUpdateUserSettingResponse> {
+  public static eventControllerDelete(
+    data: EventControllerDeleteData
+  ): CancelablePromise<EventControllerDeleteResponse> {
     return __request(OpenAPI, {
-      method: 'PUT',
-      url: '/api/v1/users/setting',
-      body: data.requestBody,
-      mediaType: 'application/json',
+      method: 'DELETE',
+      url: '/api/v1/{region}/bean/events/{id}',
+      path: {
+        id: data.id,
+        region: data.region
+      },
       errors: {
-        403: 'Insufficient permissions'
+        404: 'Life event not found'
       }
     });
   }
 
   /**
-   * Get all user settings paginated (admin only)
+   * Slice time-series by a life event (Phase 79)
+   * Returns aggregated time-series for postings matching accountPattern within the half-open date range of the given life event.
    * @param data The data for the request.
-   * @param data.pageNo Page number
-   * @param data.pageSize Page size
-   * @returns unknown Settings list retrieved successfully
+   * @param data.id Life event ID
+   * @param data.accountPattern
+   * @param data.granularity
+   * @param data.region Region code for tenant context (decorative for life events)
+   * @returns unknown Time-series sliced by the life event range
    * @throws ApiError
    */
-  public static userControllerGetAllUserSettingsByPage(
-    data: UserControllerGetAllUserSettingsByPageData
-  ): CancelablePromise<UserControllerGetAllUserSettingsByPageResponse> {
+  public static eventControllerGetSlice(
+    data: EventControllerGetSliceData
+  ): CancelablePromise<EventControllerGetSliceResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/users/settings-by-page',
+      url: '/api/v1/{region}/bean/events/{id}/slice',
+      path: {
+        id: data.id,
+        region: data.region
+      },
       query: {
-        pageNo: data.pageNo,
-        pageSize: data.pageSize
+        accountPattern: data.accountPattern,
+        granularity: data.granularity
+      },
+      errors: {
+        400: 'accountPattern query param is empty',
+        404: 'Life event not found'
       }
     });
   }
+}
 
+export class OnboardingService {
   /**
-   * Get asset and liability summary for current user
-   * @returns unknown Summary retrieved successfully
+   * Bootstrap core accounts + register asset accounts with opening balances (ADR-0113)
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context. Not-yet-open codes are accepted: the universal catalog backs onboarding regardless of region (#759)
+   * @param data.requestBody
+   * @returns unknown Onboarding bootstrap result.
    * @throws ApiError
    */
-  public static userControllerGetAssetLiabilitySummary(): CancelablePromise<UserControllerGetAssetLiabilitySummaryResponse> {
+  public static onboardingControllerBootstrap(
+    data: OnboardingControllerBootstrapData
+  ): CancelablePromise<OnboardingControllerBootstrapResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/users/asset-liability-summary'
+      method: 'POST',
+      url: '/api/v1/{region}/bean/onboarding',
+      path: {
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        422: 'Invalid region/account path/duplicate paths.'
+      }
     });
   }
 }
 
-export class PropertiesService {
+export class BalanceReconciliationService {
   /**
-   * Get all system properties
-   * @returns unknown Properties retrieved successfully
+   * Preview reconciliation (book vs actual)
+   * Computes book balance, diff, Beancount-inferred tolerance, and suggested action without persisting.
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context (decorative for reconciliation)
+   * @param data.requestBody
+   * @returns ReconciliationComputeResultDto Reconciliation preview
    * @throws ApiError
    */
-  public static propertyControllerGetAll(): CancelablePromise<PropertyControllerGetAllResponse> {
+  public static reconciliationControllerCompute(
+    data: ReconciliationControllerComputeData
+  ): CancelablePromise<ReconciliationControllerComputeResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/admin/properties',
+      method: 'POST',
+      url: '/api/v1/{region}/bean/reconciliations',
+      path: {
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
       errors: {
-        401: 'Unauthorized',
-        403: 'Forbidden - insufficient permissions'
+        404: 'Account not found'
       }
     });
   }
 
   /**
-   * Get property by key
+   * Record a balance assertion
+   * Persists the reconciliation as a BeanBalance assertion (amount = actual, diffAmount = book − actual). Re-reconciling the same day/currency upserts.
    * @param data The data for the request.
-   * @param data.key Property key
-   * @returns unknown Property retrieved successfully
+   * @param data.region Region code for tenant context (decorative for reconciliation)
+   * @param data.requestBody
+   * @returns ReconciliationRecordDto Balance assertion recorded
    * @throws ApiError
    */
-  public static propertyControllerGetByKey(
-    data: PropertyControllerGetByKeyData
-  ): CancelablePromise<PropertyControllerGetByKeyResponse> {
+  public static reconciliationControllerAssert(
+    data: ReconciliationControllerAssertData
+  ): CancelablePromise<ReconciliationControllerAssertResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/admin/properties/{key}',
+      method: 'POST',
+      url: '/api/v1/{region}/bean/reconciliations/assert',
       path: {
-        key: data.key
+        region: data.region
       },
+      body: data.requestBody,
+      mediaType: 'application/json',
       errors: {
-        401: 'Unauthorized',
-        403: 'Forbidden - insufficient permissions',
-        404: 'Property not found'
+        404: 'Account not found'
       }
     });
   }
 
   /**
-   * Update a system property
+   * Generate a pad adjusting entry
+   * When book is outside tolerance, synthesizes a Beancount pad transaction (flag P) booking the diff from source_account and persists it. Source defaults to Equity:Opening-Balances.
    * @param data The data for the request.
-   * @param data.key Property key
+   * @param data.region Region code for tenant context (decorative for reconciliation)
    * @param data.requestBody
-   * @returns unknown Property updated successfully
+   * @returns PadResultDto Pad adjusting entry generated
    * @throws ApiError
    */
-  public static propertyControllerUpdate(
-    data: PropertyControllerUpdateData
-  ): CancelablePromise<PropertyControllerUpdateResponse> {
+  public static reconciliationControllerPad(
+    data: ReconciliationControllerPadData
+  ): CancelablePromise<ReconciliationControllerPadResponse> {
     return __request(OpenAPI, {
-      method: 'PUT',
-      url: '/api/v1/admin/properties/{key}',
+      method: 'POST',
+      url: '/api/v1/{region}/bean/reconciliations/pad',
       path: {
-        key: data.key
+        region: data.region
       },
       body: data.requestBody,
       mediaType: 'application/json',
       errors: {
-        401: 'Unauthorized',
-        403: 'Forbidden - insufficient permissions'
+        400: 'Book already within tolerance — no pad needed',
+        404: 'Account not found'
       }
     });
   }
 
   /**
-   * Delete a system property
+   * List reconciliation history for an account
+   * Returns recorded balance assertions (most recent first). The latest drives the account-detail "Last <date>" badge.
    * @param data The data for the request.
-   * @param data.key Property key
-   * @returns void Property deleted successfully
+   * @param data.accountId BeanAccount id
+   * @param data.region Region code for tenant context (decorative for reconciliation)
+   * @returns ReconciliationRecordDto Reconciliation history
    * @throws ApiError
    */
-  public static propertyControllerDelete(
-    data: PropertyControllerDeleteData
-  ): CancelablePromise<PropertyControllerDeleteResponse> {
+  public static reconciliationControllerHistory(
+    data: ReconciliationControllerHistoryData
+  ): CancelablePromise<ReconciliationControllerHistoryResponse> {
     return __request(OpenAPI, {
-      method: 'DELETE',
-      url: '/api/v1/admin/properties/{key}',
+      method: 'GET',
+      url: '/api/v1/{region}/bean/accounts/{accountId}/reconciliations',
       path: {
-        key: data.key
+        accountId: data.accountId,
+        region: data.region
       },
       errors: {
-        401: 'Unauthorized',
-        403: 'Forbidden - insufficient permissions',
-        404: 'Property not found'
+        404: 'Account not found'
       }
     });
   }
@@ -2436,7 +3204,7 @@ export class BeanExportService {
   /**
    * Export Beancount ledger as ZIP
    * Export all user Beancount data as a ZIP file containing ledger.beancount and yearly files in community format.
-   * @returns unknown
+   * @returns binary ZIP archive (application/zip) streamed as an attachment
    * @throws ApiError
    */
   public static exportControllerExportBeancount(): CancelablePromise<ExportControllerExportBeancountResponse> {
@@ -2504,9 +3272,12 @@ export class BeanImportService {
   }
 
   /**
+   * Import a Beancount file in community format
+   * Upload a .beancount file to import. The system parses community-format paths, converts to internal format using category metadata, auto-creates accounts, and imports transactions with deduplication. Maximum file size: 50MB. Only 1 import per user at a time.
    * @param data The data for the request.
    * @param data.region Region code for tenant context
-   * @returns unknown
+   * @param data.formData Beancount file to import
+   * @returns unknown Beancount file imported successfully
    * @throws ApiError
    */
   public static fileImportControllerImportBeancount(
@@ -2517,6 +3288,11 @@ export class BeanImportService {
       url: '/api/v1/{region}/bean/import/beancount',
       path: {
         region: data.region
+      },
+      formData: data.formData,
+      mediaType: 'multipart/form-data',
+      errors: {
+        400: 'Bad request - invalid file or no file uploaded'
       }
     });
   }
@@ -2592,126 +3368,11 @@ export class BeanImportService {
       method: 'POST',
       url: '/api/v1/{region}/bean/import/config/{importerId}/reset',
       path: {
-        importerId: data.importerId,
-        region: data.region
-      },
-      errors: {
-        400: 'Invalid input - Unsupported importer'
-      }
-    });
-  }
-}
-
-export class BeanPlatformsService {
-  /**
-   * Get all platforms with statistics
-   * @returns unknown List of platforms with binding and account counts
-   * @throws ApiError
-   */
-  public static platformControllerFindAll(): CancelablePromise<PlatformControllerFindAllResponse> {
-    return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/bean/platforms'
-    });
-  }
-
-  /**
-   * Create a new platform
-   * @param data The data for the request.
-   * @param data.requestBody
-   * @returns unknown Platform created successfully
-   * @throws ApiError
-   */
-  public static platformControllerCreate(
-    data: PlatformControllerCreateData
-  ): CancelablePromise<PlatformControllerCreateResponse> {
-    return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/bean/platforms',
-      body: data.requestBody,
-      mediaType: 'application/json',
-      errors: {
-        409: 'Platform already exists'
-      }
-    });
-  }
-
-  /**
-   * Get platform list for current user
-   * @returns unknown List of platforms with user binding status
-   * @throws ApiError
-   */
-  public static platformControllerGetPlatformList(): CancelablePromise<PlatformControllerGetPlatformListResponse> {
-    return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/bean/platforms/list'
-    });
-  }
-
-  /**
-   * Match platforms by name or alias
-   * @param data The data for the request.
-   * @param data.q Search query — Chinese name, English name, or abbreviation
-   * @param data.region Region code for category override lookup
-   * @returns unknown List of matching platforms with suggested segment names
-   * @throws ApiError
-   */
-  public static platformControllerMatchPlatforms(
-    data: PlatformControllerMatchPlatformsData
-  ): CancelablePromise<PlatformControllerMatchPlatformsResponse> {
-    return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/bean/platforms/match',
-      query: {
-        q: data.q,
-        region: data.region
-      }
-    });
-  }
-
-  /**
-   * Update a platform
-   * @param data The data for the request.
-   * @param data.id Platform ID
-   * @param data.requestBody
-   * @returns unknown Platform updated successfully
-   * @throws ApiError
-   */
-  public static platformControllerUpdate(
-    data: PlatformControllerUpdateData
-  ): CancelablePromise<PlatformControllerUpdateResponse> {
-    return __request(OpenAPI, {
-      method: 'PUT',
-      url: '/api/v1/bean/platforms/{id}',
-      path: {
-        id: data.id
-      },
-      body: data.requestBody,
-      mediaType: 'application/json',
-      errors: {
-        404: 'Platform not found'
-      }
-    });
-  }
-
-  /**
-   * Delete a platform
-   * @param data The data for the request.
-   * @param data.id Platform ID
-   * @returns void Platform deleted successfully
-   * @throws ApiError
-   */
-  public static platformControllerDelete(
-    data: PlatformControllerDeleteData
-  ): CancelablePromise<PlatformControllerDeleteResponse> {
-    return __request(OpenAPI, {
-      method: 'DELETE',
-      url: '/api/v1/bean/platforms/{id}',
-      path: {
-        id: data.id
+        importerId: data.importerId,
+        region: data.region
       },
       errors: {
-        404: 'Platform not found'
+        400: 'Invalid input - Unsupported importer'
       }
     });
   }
@@ -2719,11 +3380,33 @@ export class BeanPlatformsService {
 
 export class ProviderSyncService {
   /**
+   * Sync transactions from financial data provider
+   *
+   * Accepts raw transactions from external financial data providers, transforms them to Beancount format, and processes them through the ingestion pipeline.
+   *
+   * **Supported Providers:**
+   * - **plaid**: Plaid API (US, Canada, Europe)
+   * - **teller**: Teller API (US)
+   * - **truelayer**: TrueLayer Open Banking (UK, Europe)
+   * - **gocardless**: GoCardless Bank Account Data (Europe)
+   * - **simplefin**: SimpleFIN (Self-hosted)
+   * - **yodlee**: Yodlee (Global)
+   * - **beancount-direct**: Beancount format transactions
+   * - **parsed-bill**: Client-side parsed bill transactions
+   *
+   * **Processing Flow:**
+   * 1. Transform raw data via provider adapter
+   * 2. Validate transaction format
+   * 3. Deduplicate using originalId
+   * 4. Classify using rule engine
+   * 5. Route low-confidence to Review Center
+   * 6. Persist validated transactions
+   *
    * @param data The data for the request.
-   * @param data.providerName
+   * @param data.providerName Provider name
    * @param data.region Region code for tenant context
    * @param data.requestBody
-   * @returns unknown
+   * @returns ProviderSyncResponseDto Sync completed successfully
    * @throws ApiError
    */
   public static providerSyncControllerSync(
@@ -2737,7 +3420,12 @@ export class ProviderSyncService {
         region: data.region
       },
       body: data.requestBody,
-      mediaType: 'application/json'
+      mediaType: 'application/json',
+      errors: {
+        400: 'Invalid request data',
+        401: 'Missing or invalid authentication',
+        404: 'Provider not supported'
+      }
     });
   }
 
@@ -2790,6 +3478,101 @@ export class ProviderSyncService {
   }
 }
 
+export class ExternalAccountLinksService {
+  /**
+   * Create an external account → BeanAccount mapping (ADR-0113)
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns ExternalAccountLinkResponseDto Link created.
+   * @throws ApiError
+   */
+  public static externalAccountLinkControllerCreate(
+    data: ExternalAccountLinkControllerCreateData
+  ): CancelablePromise<ExternalAccountLinkControllerCreateResponse> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/{region}/bean/external-account-links',
+      path: {
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        422: 'beanAccountId not owned, or an active link already exists.'
+      }
+    });
+  }
+
+  /**
+   * List the user's active external account links
+   * @param data The data for the request.
+   * @param data.provider
+   * @param data.region Region code for tenant context
+   * @returns ExternalAccountLinkListResponseDto Links retrieved.
+   * @throws ApiError
+   */
+  public static externalAccountLinkControllerFindAll(
+    data: ExternalAccountLinkControllerFindAllData
+  ): CancelablePromise<ExternalAccountLinkControllerFindAllResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/bean/external-account-links',
+      path: {
+        region: data.region
+      },
+      query: {
+        provider: data.provider
+      }
+    });
+  }
+
+  /**
+   * Get a single external account link
+   * @param data The data for the request.
+   * @param data.id
+   * @param data.region Region code for tenant context
+   * @returns ExternalAccountLinkResponseDto Link retrieved.
+   * @throws ApiError
+   */
+  public static externalAccountLinkControllerFindOne(
+    data: ExternalAccountLinkControllerFindOneData
+  ): CancelablePromise<ExternalAccountLinkControllerFindOneResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/bean/external-account-links/{id}',
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      errors: {
+        422: 'Link not found or not owned by the user.'
+      }
+    });
+  }
+
+  /**
+   * Soft-delete (disconnect) an external account link
+   * @param data The data for the request.
+   * @param data.id
+   * @param data.region Region code for tenant context
+   * @returns void Link soft-deleted; historical transactions are unaffected.
+   * @throws ApiError
+   */
+  public static externalAccountLinkControllerRemove(
+    data: ExternalAccountLinkControllerRemoveData
+  ): CancelablePromise<ExternalAccountLinkControllerRemoveResponse> {
+    return __request(OpenAPI, {
+      method: 'DELETE',
+      url: '/api/v1/{region}/bean/external-account-links/{id}',
+      path: {
+        id: data.id,
+        region: data.region
+      }
+    });
+  }
+}
+
 export class ImportTelemetryService {
   /**
    * Receive anonymous parser failure telemetry
@@ -2867,10 +3650,12 @@ export class ImportTelemetryService {
 
 export class BeanNlpService {
   /**
+   * Process natural language input
+   * Parse natural language text (Chinese/English) describing a transaction. Supports multi-turn dialogue for collecting missing information. When confidence < 0.75, returns "confirm" action requiring user verification. User can reply with confirmation words (确认/yes/ok) or provide corrections. Examples: "yesterday Starbucks spent 35 yuan", "today lunch 28 yuan", "spent $50 at Walmart"
    * @param data The data for the request.
    * @param data.region Region code for tenant context
-   * @param data.requestBody
-   * @returns unknown
+   * @param data.requestBody Natural language transaction input with optional session ID
+   * @returns NlpResponseDto NLP processing result - either created transaction or asking for more info
    * @throws ApiError
    */
   public static nlpControllerProcessNaturalLanguage(
@@ -2883,7 +3668,11 @@ export class BeanNlpService {
         region: data.region
       },
       body: data.requestBody,
-      mediaType: 'application/json'
+      mediaType: 'application/json',
+      errors: {
+        400: 'Invalid input',
+        401: 'Unauthorized'
+      }
     });
   }
 
@@ -2942,411 +3731,302 @@ export class BeanNlpService {
   }
 }
 
-export class DashboardService {
+export class BeanPlatformsService {
   /**
-   * Get net worth overview
-   * Returns total net worth with breakdown of assets and liabilities
-   * @param data The data for the request.
-   * @param data.region Region code for tenant context
-   * @param data.date Date for balance calculation (ISO 8601 format)
-   * @returns NetWorthResponseDto Net worth retrieved successfully
+   * Get all platforms with statistics
+   * @returns unknown List of platforms with binding and account counts
    * @throws ApiError
    */
-  public static dashboardControllerGetNetWorth(
-    data: DashboardControllerGetNetWorthData
-  ): CancelablePromise<DashboardControllerGetNetWorthResponse> {
+  public static platformControllerFindAll(): CancelablePromise<PlatformControllerFindAllResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/{region}/dashboard/net-worth',
-      path: {
-        region: data.region
-      },
-      query: {
-        date: data.date
-      },
-      errors: {
-        401: 'User not authenticated'
-      }
+      url: '/api/v1/bean/platforms'
     });
   }
 
   /**
-   * Get accounts grouped by platform
-   * Returns accounts with balances grouped by financial platform
+   * Create a new platform
    * @param data The data for the request.
-   * @param data.region Region code for tenant context
-   * @param data.groupBy Grouping strategy
-   * @param data.date Date for balance calculation (ISO 8601 format)
-   * @param data.accountId Scope to a single account (only valid with groupBy=holdingAssetClass, ADR-0105 §6)
-   * @returns unknown Accounts retrieved successfully. Response type depends on groupBy parameter.
+   * @param data.requestBody
+   * @returns unknown Platform created successfully
    * @throws ApiError
    */
-  public static dashboardControllerGetAccounts(
-    data: DashboardControllerGetAccountsData
-  ): CancelablePromise<DashboardControllerGetAccountsResponse> {
+  public static platformControllerCreate(
+    data: PlatformControllerCreateData
+  ): CancelablePromise<PlatformControllerCreateResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/{region}/dashboard/accounts',
-      path: {
-        region: data.region
-      },
-      query: {
-        groupBy: data.groupBy,
-        date: data.date,
-        accountId: data.accountId
-      },
+      method: 'POST',
+      url: '/api/v1/bean/platforms',
+      body: data.requestBody,
+      mediaType: 'application/json',
       errors: {
-        401: 'User not authenticated'
+        409: 'Platform already exists'
       }
     });
   }
 
   /**
-   * Get cash flow summary
-   * Returns income, expenses, and savings for a monthly period
+   * Get platform list for current user
    * @param data The data for the request.
-   * @param data.period Period in YYYY-MM format
-   * @param data.region Region code for tenant context
-   * @returns CashFlowResponseDto Cash flow retrieved successfully
+   * @param data.region Region code (ISO 3166-1 alpha-2) that biases within-type-bucket ordering (local-region platforms first). Case-insensitive — stored/compared UPPERCASE ("cn" == "CN").
+   * @returns PlatformListItemDto List of platforms with user binding status
    * @throws ApiError
    */
-  public static dashboardControllerGetCashFlow(
-    data: DashboardControllerGetCashFlowData
-  ): CancelablePromise<DashboardControllerGetCashFlowResponse> {
+  public static platformControllerGetPlatformList(
+    data: PlatformControllerGetPlatformListData = {}
+  ): CancelablePromise<PlatformControllerGetPlatformListResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/{region}/dashboard/cash-flow',
-      path: {
-        region: data.region
-      },
+      url: '/api/v1/bean/platforms/list',
       query: {
-        period: data.period
-      },
-      errors: {
-        400: 'Invalid period format',
-        401: 'User not authenticated'
+        region: data.region
       }
     });
   }
-}
 
-export class InvestmentService {
   /**
-   * Get per-holding unrealized + realized P&L
-   * Average-cost unrealized P&L per account × commodity, plus cumulative realized P&L on sold lots (method = FIFO | average, default average).
+   * Match platforms by name or alias
    * @param data The data for the request.
-   * @param data.region Region code for tenant context
-   * @param data.asOf As-of date (ISO 8601), defaults to today
-   * @param data.accountId Scope to a single account
-   * @param data.method Realized-P&L lot-matching method (default average). Does not affect the average-cost unrealized basis.
-   * @returns HoldingPnlResponseDto Holding P&L retrieved successfully
+   * @param data.q Search query — Chinese name, English name, or abbreviation
+   * @param data.region Region code (ISO 3166-1 alpha-2) that biases within-tier ordering (local-region platforms first); also the intended categoryOverrides key. Case-insensitive — stored/compared UPPERCASE ("cn" == "CN").
+   * @returns PlatformMatchResponseDto Matching platforms with overall match type and truncation flag
    * @throws ApiError
    */
-  public static holdingPnlControllerGetHoldingPnl(
-    data: HoldingPnlControllerGetHoldingPnlData
-  ): CancelablePromise<HoldingPnlControllerGetHoldingPnlResponse> {
+  public static platformControllerMatchPlatforms(
+    data: PlatformControllerMatchPlatformsData
+  ): CancelablePromise<PlatformControllerMatchPlatformsResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/{region}/investment/holdings/pnl',
-      path: {
-        region: data.region
-      },
+      url: '/api/v1/bean/platforms/match',
       query: {
-        asOf: data.asOf,
-        accountId: data.accountId,
-        method: data.method
-      },
-      errors: {
-        400: 'Invalid asOf format/value/future date, invalid accountId format, or unsupported method',
-        401: 'User not authenticated'
-      }
-    });
-  }
-}
-
-export class BeanPricesService {
-  /**
-   * Create a new price
-   * Creates a new price entry for the authenticated user
-   * @param data The data for the request.
-   * @param data.region Region code for tenant context
-   * @param data.requestBody
-   * @returns PriceResponseDto Price created successfully
-   * @throws ApiError
-   */
-  public static priceControllerCreate(
-    data: PriceControllerCreateData
-  ): CancelablePromise<PriceControllerCreateResponse> {
-    return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/{region}/bean/prices',
-      path: {
+        q: data.q,
         region: data.region
-      },
-      body: data.requestBody,
-      mediaType: 'application/json',
-      errors: {
-        404: 'Currency or quoteCurrency commodity not found',
-        409: 'Price already exists for this currency pair and date'
       }
     });
   }
 
   /**
-   * List user prices
-   * Returns all price entries for the authenticated user with optional filtering
+   * Get the region and candidate account standards for a platform
    * @param data The data for the request.
-   * @param data.region Region code for tenant context
-   * @param data.currency Filter by currency (e.g., BTC, AAPL, USD)
-   * @param data.quoteCurrency Filter by quote currency (pricing currency, e.g., USD, CNY)
-   * @param data.dateFrom Filter prices from this date (ISO 8601 format)
-   * @param data.dateTo Filter prices to this date (ISO 8601 format)
-   * @param data.search Search term for currency or quoteCurrency (case-insensitive partial match)
-   * @param data.page Page number for pagination (default: 1)
-   * @param data.limit Number of items per page (default: 20, max: 100)
-   * @returns PriceListResponseDto Prices retrieved successfully
+   * @param data.id Platform ID (from a match result)
+   * @param data.region Region code (ISO 3166-1 alpha-2, case-insensitive). Required for global platforms (countryCode null) — resolved as their template region; ignored when the platform has its own countryCode.
+   * @param data.type Filter templates by account type (path first segment)
+   * @returns PlatformStandardsResponseDto Resolved region plus the merged account-standard catalog of that region (groupable by productCategory client-side)
    * @throws ApiError
    */
-  public static priceControllerFindAll(
-    data: PriceControllerFindAllData
-  ): CancelablePromise<PriceControllerFindAllResponse> {
+  public static platformControllerGetPlatformStandards(
+    data: PlatformControllerGetPlatformStandardsData
+  ): CancelablePromise<PlatformControllerGetPlatformStandardsResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/{region}/bean/prices',
+      url: '/api/v1/bean/platforms/{id}/standards',
       path: {
-        region: data.region
+        id: data.id
       },
       query: {
-        currency: data.currency,
-        quoteCurrency: data.quoteCurrency,
-        dateFrom: data.dateFrom,
-        dateTo: data.dateTo,
-        search: data.search,
-        page: data.page,
-        limit: data.limit
+        region: data.region,
+        type: data.type
       }
     });
   }
 
   /**
-   * Get price by ID
-   * Returns a single price entry by its ID
+   * Update a platform
    * @param data The data for the request.
-   * @param data.id Price ID
-   * @param data.region Region code for tenant context
-   * @returns PriceResponseDto Price retrieved successfully
+   * @param data.id Platform ID
+   * @param data.requestBody
+   * @returns unknown Platform updated successfully
    * @throws ApiError
    */
-  public static priceControllerFindOne(
-    data: PriceControllerFindOneData
-  ): CancelablePromise<PriceControllerFindOneResponse> {
+  public static platformControllerUpdate(
+    data: PlatformControllerUpdateData
+  ): CancelablePromise<PlatformControllerUpdateResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/{region}/bean/prices/{id}',
+      method: 'PUT',
+      url: '/api/v1/bean/platforms/{id}',
       path: {
-        id: data.id,
-        region: data.region
+        id: data.id
       },
+      body: data.requestBody,
+      mediaType: 'application/json',
       errors: {
-        404: 'Price not found'
+        404: 'Platform not found'
       }
     });
   }
 
   /**
-   * Update a price
-   * Updates an existing price entry
+   * Delete a platform
    * @param data The data for the request.
-   * @param data.id Price ID
-   * @param data.region Region code for tenant context
-   * @param data.requestBody
-   * @returns PriceResponseDto Price updated successfully
+   * @param data.id Platform ID
+   * @returns void Platform deleted successfully
    * @throws ApiError
    */
-  public static priceControllerUpdate(
-    data: PriceControllerUpdateData
-  ): CancelablePromise<PriceControllerUpdateResponse> {
+  public static platformControllerDelete(
+    data: PlatformControllerDeleteData
+  ): CancelablePromise<PlatformControllerDeleteResponse> {
     return __request(OpenAPI, {
-      method: 'PUT',
-      url: '/api/v1/{region}/bean/prices/{id}',
+      method: 'DELETE',
+      url: '/api/v1/bean/platforms/{id}',
       path: {
-        id: data.id,
-        region: data.region
+        id: data.id
       },
-      body: data.requestBody,
-      mediaType: 'application/json',
       errors: {
-        404: 'Price not found',
-        409: 'Updated price conflicts with existing price'
+        404: 'Platform not found'
       }
     });
   }
+}
 
+export class DashboardService {
   /**
-   * Delete a price
-   * Deletes a price entry (hard delete)
+   * Get net worth overview
+   * Returns total net worth with breakdown of assets and liabilities
    * @param data The data for the request.
-   * @param data.id Price ID
    * @param data.region Region code for tenant context
-   * @returns void Price deleted successfully
+   * @param data.date Date for balance calculation (ISO 8601 format)
+   * @returns NetWorthResponseDto Net worth retrieved successfully
    * @throws ApiError
    */
-  public static priceControllerDelete(
-    data: PriceControllerDeleteData
-  ): CancelablePromise<PriceControllerDeleteResponse> {
+  public static dashboardControllerGetNetWorth(
+    data: DashboardControllerGetNetWorthData
+  ): CancelablePromise<DashboardControllerGetNetWorthResponse> {
     return __request(OpenAPI, {
-      method: 'DELETE',
-      url: '/api/v1/{region}/bean/prices/{id}',
+      method: 'GET',
+      url: '/api/v1/{region}/dashboard/net-worth',
       path: {
-        id: data.id,
         region: data.region
       },
+      query: {
+        date: data.date
+      },
       errors: {
-        404: 'Price not found'
+        401: 'User not authenticated'
       }
     });
   }
 
   /**
-   * Bulk create prices
-   * Creates multiple price entries at once (skips duplicates)
+   * Get accounts grouped by platform
+   * Returns accounts with balances grouped by financial platform
    * @param data The data for the request.
    * @param data.region Region code for tenant context
-   * @param data.requestBody
-   * @returns PriceResponseDto Prices created successfully
+   * @param data.groupBy Grouping strategy
+   * @param data.date Date for balance calculation (ISO 8601 format)
+   * @param data.accountId Scope to a single account (only valid with groupBy=holdingAssetClass, ADR-0105 §6)
+   * @returns unknown Accounts retrieved successfully. Response type depends on groupBy parameter.
    * @throws ApiError
    */
-  public static priceControllerBulkCreate(
-    data: PriceControllerBulkCreateData
-  ): CancelablePromise<PriceControllerBulkCreateResponse> {
+  public static dashboardControllerGetAccounts(
+    data: DashboardControllerGetAccountsData
+  ): CancelablePromise<DashboardControllerGetAccountsResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/{region}/bean/prices/bulk',
+      method: 'GET',
+      url: '/api/v1/{region}/dashboard/accounts',
       path: {
         region: data.region
       },
-      body: data.requestBody,
-      mediaType: 'application/json'
+      query: {
+        groupBy: data.groupBy,
+        date: data.date,
+        accountId: data.accountId
+      },
+      errors: {
+        401: 'User not authenticated'
+      }
     });
   }
-}
 
-export class ReportingService {
   /**
-   * Get portfolio value trends
-   *
-   * Returns time series data of portfolio net worth.
-   *
-   * **Multi-currency Support:**
-   * - `series[].byCurrency` - Currency breakdown for each data point
-   * - `byCurrency` - Separate time series grouped by currency
-   * - `warnings` - Exchange rate warnings if conversion failed
-   *
-   * **Parameters:**
-   * - `period`: Time period (1m, 3m, 6m, 1y)
-   * - `granularity`: Data granularity (day, week, month)
-   *
+   * Get cash flow summary
+   * Returns income, expenses, and savings for a monthly period
    * @param data The data for the request.
+   * @param data.period Period in YYYY-MM format
    * @param data.region Region code for tenant context
-   * @param data.period Time period
-   * @param data.granularity Data granularity
-   * @returns PortfolioTrendsResponseDto Trends retrieved successfully
+   * @returns CashFlowResponseDto Cash flow retrieved successfully
    * @throws ApiError
    */
-  public static reportingControllerGetPortfolioTrends(
-    data: ReportingControllerGetPortfolioTrendsData
-  ): CancelablePromise<ReportingControllerGetPortfolioTrendsResponse> {
+  public static dashboardControllerGetCashFlow(
+    data: DashboardControllerGetCashFlowData
+  ): CancelablePromise<DashboardControllerGetCashFlowResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/{region}/reporting/portfolio/trends',
+      url: '/api/v1/{region}/dashboard/cash-flow',
       path: {
         region: data.region
       },
       query: {
-        period: data.period,
-        granularity: data.granularity
+        period: data.period
       },
       errors: {
+        400: 'Invalid period format',
         401: 'User not authenticated'
       }
     });
   }
 
   /**
-   * Generate portfolio snapshot
-   *
-   * Manually generate a portfolio snapshot for a specific date.
-   *
-   * **Multi-currency Support:**
-   * - Fetches balances grouped by currency
-   * - Uses user's baseCurrency setting for conversion
-   * - Stores exchange rates and warnings
-   *
-   * **Use Cases:**
-   * - Testing snapshot generation
-   * - Force regeneration after data correction
-   * - Initial setup for new users
-   *
+   * Get expenses/income grouped by functional category
+   * Returns amounts pre-aggregated by functional category (account-path Group segment) with server-side multi-currency conversion. flow=expense (default) aggregates ^Expenses: accounts; flow=income aggregates ^Income: accounts (issue #518)
    * @param data The data for the request.
    * @param data.region Region code for tenant context
-   * @param data.requestBody Optional date (defaults to today)
-   * @returns GenerateSnapshotResponse Snapshot generated successfully
+   * @param data.groupBy Grouping strategy
+   * @param data.period Time window (1m = current calendar month)
+   * @param data.flow Account root to aggregate (expense → ^Expenses:, income → ^Income:)
+   * @returns ExpensesByCategoryResponseDto Expenses retrieved successfully
    * @throws ApiError
    */
-  public static reportingControllerGenerateSnapshot(
-    data: ReportingControllerGenerateSnapshotData
-  ): CancelablePromise<ReportingControllerGenerateSnapshotResponse> {
+  public static dashboardControllerGetExpenses(
+    data: DashboardControllerGetExpensesData
+  ): CancelablePromise<DashboardControllerGetExpensesResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/{region}/reporting/snapshots/generate',
+      method: 'GET',
+      url: '/api/v1/{region}/dashboard/expenses',
       path: {
         region: data.region
       },
-      body: data.requestBody,
-      mediaType: 'application/json',
+      query: {
+        groupBy: data.groupBy,
+        period: data.period,
+        flow: data.flow
+      },
       errors: {
-        400: 'Invalid date format',
+        400: 'Invalid groupBy or period',
         401: 'User not authenticated'
       }
     });
   }
+}
 
+export class InvestmentService {
   /**
-   * Backfill portfolio snapshots
-   *
-   * Generate snapshots for a date range (historical data backfill).
-   *
-   * **Multi-currency Support:**
-   * - Each snapshot includes multi-currency data
-   * - Uses exchange rates available at generation time
-   * - Warnings stored for missing exchange rates
-   *
-   * **Best Practices:**
-   * - Use for initial setup after account configuration
-   * - Run during low-traffic periods for large date ranges
-   * - Existing snapshots are skipped (not regenerated)
-   *
+   * Get per-holding unrealized + realized P&L
+   * Average-cost unrealized P&L per account × commodity, plus cumulative realized P&L on sold lots (method = FIFO | average, default average).
    * @param data The data for the request.
    * @param data.region Region code for tenant context
-   * @param data.requestBody
-   * @returns BackfillSnapshotsResponse Backfill completed successfully
+   * @param data.asOf As-of date (ISO 8601), defaults to today
+   * @param data.accountId Scope to a single account
+   * @param data.method Realized-P&L lot-matching method (default average). Does not affect the average-cost unrealized basis.
+   * @returns HoldingPnlResponseDto Holding P&L retrieved successfully
    * @throws ApiError
    */
-  public static reportingControllerBackfillSnapshots(
-    data: ReportingControllerBackfillSnapshotsData
-  ): CancelablePromise<ReportingControllerBackfillSnapshotsResponse> {
+  public static holdingPnlControllerGetHoldingPnl(
+    data: HoldingPnlControllerGetHoldingPnlData
+  ): CancelablePromise<HoldingPnlControllerGetHoldingPnlResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/{region}/reporting/snapshots/backfill',
+      method: 'GET',
+      url: '/api/v1/{region}/investment/holdings/pnl',
       path: {
         region: data.region
       },
-      body: data.requestBody,
-      mediaType: 'application/json',
+      query: {
+        asOf: data.asOf,
+        accountId: data.accountId,
+        method: data.method
+      },
       errors: {
-        400: 'Invalid date format or range',
-        401: 'User not authenticated',
-        409: 'Backfill already in progress for this user'
+        400: 'Invalid asOf format/value/future date, invalid accountId format, or unsupported method',
+        401: 'User not authenticated'
       }
     });
   }
@@ -3375,7 +4055,7 @@ export class AuthService {
    * Anonymous login with access token
    * @param data The data for the request.
    * @param data.requestBody
-   * @returns unknown Login successful
+   * @returns AnonymousLoginResponseDto Login successful
    * @throws ApiError
    */
   public static authControllerAccessTokenLogin(
@@ -3393,15 +4073,52 @@ export class AuthService {
   }
 }
 
-export class DefaultService {
+export class CommunityService {
+  /**
+   * Relay a sanitized parser-contribution payload
+   * A server-side bot re-sanitizes the payload and opens an issue on the target repository; the issue URL is returned. The payload is never persisted or logged (forward-and-drop).
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context (routing only; the institution region rides in the payload meta)
+   * @param data.requestBody
+   * @returns ParserContributionRelayResponseDto Issue created by the bot
+   * @throws ApiError
+   */
+  public static parserContributionControllerCreate(
+    data: ParserContributionControllerCreateData
+  ): CancelablePromise<ParserContributionControllerCreateResponse> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/{region}/community/parser-contributions',
+      path: {
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        401: 'Unauthorized',
+        422: 'Validation failed (institution slug, empty samples, row/cell size limits)',
+        429: 'Rate limited (5 submissions per user per hour)',
+        501: 'Relay not configured on this deployment — clients fall back to the clipboard flow',
+        502: 'GitHub bot failure (upstream), safe to retry'
+      }
+    });
+  }
+}
+
+export class AdminCacheService {
   /**
-   * @returns unknown
+   * Flush entire cache (L1 + L2)
+   * Clears ALL cache entries across ALL namespaces and users. Use only for emergency cache corruption recovery, maintenance-window refresh, or development resets.
+   * @returns unknown Cache flushed successfully
    * @throws ApiError
    */
   public static cacheControllerFlushCache(): CancelablePromise<CacheControllerFlushCacheResponse> {
     return __request(OpenAPI, {
       method: 'POST',
-      url: '/api/v1/cache/flush'
+      url: '/api/v1/cache/flush',
+      errors: {
+        403: 'Admin access required'
+      }
     });
   }
 }
@@ -3562,3 +4279,53 @@ export class InfoService {
     });
   }
 }
+
+export class MarketDataService {
+  /**
+   * Search market symbols by name or code
+   * Ranked search over the openbb catalog. Empty `q` returns [].
+   * @param data The data for the request.
+   * @param data.q Search term — matched against symbol and instrument name. Empty string returns [].
+   * @param data.limit Maximum number of results (clamped 1..50)
+   * @param data.exchange Filter by exchange code (e.g. US, HK, SS, SZ)
+   * @param data.assetType Filter by OpenBB asset_type (e.g. stock, etf)
+   * @returns SymbolSearchResultDto Ranked search results
+   * @throws ApiError
+   */
+  public static symbolControllerSearch(
+    data: SymbolControllerSearchData
+  ): CancelablePromise<SymbolControllerSearchResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/market/symbols/search',
+      query: {
+        q: data.q,
+        limit: data.limit,
+        exchange: data.exchange,
+        assetType: data.assetType
+      }
+    });
+  }
+
+  /**
+   * Get a market symbol quote
+   * @param data The data for the request.
+   * @param data.symbol
+   * @returns SymbolQuoteDto Symbol quote
+   * @throws ApiError
+   */
+  public static symbolControllerGetQuote(
+    data: SymbolControllerGetQuoteData
+  ): CancelablePromise<SymbolControllerGetQuoteResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/market/symbols/{symbol}/quote',
+      path: {
+        symbol: data.symbol
+      },
+      errors: {
+        404: 'Symbol not found in the openbb catalog'
+      }
+    });
+  }
+}