@firela/api-types 0.0.0-canary.b3b7767b → 0.0.0-canary.b59261c8

package/src/generated/services.gen.ts

@@ -17,22 +17,30 @@ import type {
   AccountControllerCloseResponse,
   AccountControllerReopenData,
   AccountControllerReopenResponse,
+  AccountControllerAddOpeningBalanceData,
+  AccountControllerAddOpeningBalanceResponse,
+  AccountStandardsControllerGetTemplatesData,
+  AccountStandardsControllerGetTemplatesResponse,
+  AccountStandardsControllerGetTemplateMetadataData,
+  AccountStandardsControllerGetTemplateMetadataResponse,
+  AccountStandardsControllerGetRegionsData,
+  AccountStandardsControllerGetRegionsResponse,
   TransactionControllerCreateData,
   TransactionControllerCreateResponse,
   TransactionControllerListData,
   TransactionControllerListResponse,
-  TransactionControllerData,
-  TransactionControllerResponse,
+  TransactionControllerCreateBatchData,
+  TransactionControllerCreateBatchResponse,
+  TransactionControllerCorrectData,
+  TransactionControllerCorrectResponse,
+  TransactionControllerSuggestTagsData,
+  TransactionControllerSuggestTagsResponse,
   TransactionControllerGetDetailData,
   TransactionControllerGetDetailResponse,
   TransactionControllerUpdateData,
   TransactionControllerUpdateResponse,
-  TransactionController1Data,
-  TransactionController1Response,
-  AccountStandardsControllerGetTemplatesData,
-  AccountStandardsControllerGetTemplatesResponse,
-  AccountStandardsControllerGetRegionsData,
-  AccountStandardsControllerGetRegionsResponse,
+  TransactionControllerDeleteData,
+  TransactionControllerDeleteResponse,
   BalanceControllerGetBalanceData,
   BalanceControllerGetBalanceResponse,
   BalanceControllerGetMultiCurrencyBalanceData,
@@ -43,14 +51,14 @@ import type {
   ReviewControllerGetStatsResponse,
   ReviewControllerFindOneData,
   ReviewControllerFindOneResponse,
-  ReviewControllerData,
-  ReviewControllerResponse,
-  ReviewController1Data,
-  ReviewController1Response,
-  ReviewController2Data,
-  ReviewController2Response,
-  PayeeControllerData,
-  PayeeControllerResponse,
+  ReviewControllerResolveData,
+  ReviewControllerResolveResponse,
+  ReviewControllerUndoData,
+  ReviewControllerUndoResponse,
+  ReviewControllerBatchResolveData,
+  ReviewControllerBatchResolveResponse,
+  PayeeControllerCreateData,
+  PayeeControllerCreateResponse,
   PayeeControllerFindAllData,
   PayeeControllerFindAllResponse,
   PayeeControllerAutocompleteData,
@@ -59,50 +67,62 @@ import type {
   PayeeControllerGetTopPayeesResponse,
   PayeeControllerFindOneData,
   PayeeControllerFindOneResponse,
-  PayeeController1Data,
-  PayeeController1Response,
-  PayeeController2Data,
-  PayeeController2Response,
-  PayeeProfileAdminControllerData,
-  PayeeProfileAdminControllerResponse,
+  PayeeControllerUpdateData,
+  PayeeControllerUpdateResponse,
+  PayeeControllerDeleteData,
+  PayeeControllerDeleteResponse,
+  PayeeProfileAdminControllerCreateData,
+  PayeeProfileAdminControllerCreateResponse,
   PayeeProfileAdminControllerFindAllData,
   PayeeProfileAdminControllerFindAllResponse,
   PayeeProfileAdminControllerFindOneData,
   PayeeProfileAdminControllerFindOneResponse,
-  PayeeProfileAdminController1Data,
-  PayeeProfileAdminController1Response,
-  PayeeProfileAdminController2Data,
-  PayeeProfileAdminController2Response,
-  PayeeProfileAdminController3Data,
-  PayeeProfileAdminController3Response,
-  PayeeProfileAdminController4Data,
-  PayeeProfileAdminController4Response,
-  CommodityControllerData,
-  CommodityControllerResponse,
+  PayeeProfileAdminControllerUpdateData,
+  PayeeProfileAdminControllerUpdateResponse,
+  PayeeProfileAdminControllerDeleteData,
+  PayeeProfileAdminControllerDeleteResponse,
+  PayeeProfileAdminControllerVerifyData,
+  PayeeProfileAdminControllerVerifyResponse,
+  PayeeProfileAdminControllerUnverifyData,
+  PayeeProfileAdminControllerUnverifyResponse,
+  CommodityControllerCreateData,
+  CommodityControllerCreateResponse,
   CommodityControllerFindAllData,
   CommodityControllerFindAllResponse,
   CommodityControllerFindOneData,
   CommodityControllerFindOneResponse,
-  CommodityController1Data,
-  CommodityController1Response,
-  CommodityController2Data,
-  CommodityController2Response,
-  CommodityController3Data,
-  CommodityController3Response,
-  CommodityController4Data,
-  CommodityController4Response,
-  RecurringRuleControllerData,
-  RecurringRuleControllerResponse,
+  CommodityControllerUpdateData,
+  CommodityControllerUpdateResponse,
+  CommodityControllerDeleteData,
+  CommodityControllerDeleteResponse,
+  CommodityControllerGetOrCreateData,
+  CommodityControllerGetOrCreateResponse,
+  CommodityControllerBulkCreateData,
+  CommodityControllerBulkCreateResponse,
+  PriceControllerCreateData,
+  PriceControllerCreateResponse,
+  PriceControllerFindAllData,
+  PriceControllerFindAllResponse,
+  PriceControllerFindOneData,
+  PriceControllerFindOneResponse,
+  PriceControllerUpdateData,
+  PriceControllerUpdateResponse,
+  PriceControllerDeleteData,
+  PriceControllerDeleteResponse,
+  PriceControllerBulkCreateData,
+  PriceControllerBulkCreateResponse,
+  RecurringRuleControllerCreateData,
+  RecurringRuleControllerCreateResponse,
   RecurringRuleControllerFindAllData,
   RecurringRuleControllerFindAllResponse,
-  RecurringRuleController1Data,
-  RecurringRuleController1Response,
+  RecurringRuleControllerCreateFromTransactionData,
+  RecurringRuleControllerCreateFromTransactionResponse,
   RecurringRuleControllerFindOneData,
   RecurringRuleControllerFindOneResponse,
-  RecurringRuleController2Data,
-  RecurringRuleController2Response,
-  RecurringRuleController3Data,
-  RecurringRuleController3Response,
+  RecurringRuleControllerUpdateData,
+  RecurringRuleControllerUpdateResponse,
+  RecurringRuleControllerDeleteData,
+  RecurringRuleControllerDeleteResponse,
   RecurringRuleControllerGetWithStatsData,
   RecurringRuleControllerGetWithStatsResponse,
   ExpectedTransactionControllerFindAllData,
@@ -111,38 +131,26 @@ import type {
   ExpectedTransactionControllerFindOverdueResponse,
   ExpectedTransactionControllerFindOneData,
   ExpectedTransactionControllerFindOneResponse,
-  ExpectedTransactionControllerData,
-  ExpectedTransactionControllerResponse,
-  ExpectedTransactionController1Data,
-  ExpectedTransactionController1Response,
-  ExpectedTransactionController2Data,
-  ExpectedTransactionController2Response,
-  ExpectedTransactionController3Data,
-  ExpectedTransactionController3Response,
-  ExpectedTransactionController4Data,
-  ExpectedTransactionController4Response,
+  ExpectedTransactionControllerSkipData,
+  ExpectedTransactionControllerSkipResponse,
+  ExpectedTransactionControllerUndoSkipData,
+  ExpectedTransactionControllerUndoSkipResponse,
+  ExpectedTransactionControllerConfirmMatchData,
+  ExpectedTransactionControllerConfirmMatchResponse,
+  ExpectedTransactionControllerUnmatchData,
+  ExpectedTransactionControllerUnmatchResponse,
+  ExpectedTransactionControllerEnterNowData,
+  ExpectedTransactionControllerEnterNowResponse,
   ForecastControllerGetForecastData,
   ForecastControllerGetForecastResponse,
-  TransactionRuleControllerData,
-  TransactionRuleControllerResponse,
-  TransactionRuleControllerListData,
-  TransactionRuleControllerListResponse,
-  TransactionRuleControllerValidateData,
-  TransactionRuleControllerValidateResponse,
-  TransactionRuleController1Data,
-  TransactionRuleController1Response,
-  TransactionRuleControllerExportData,
-  TransactionRuleControllerExportResponse,
-  TransactionRuleControllerGetStatisticsData,
-  TransactionRuleControllerGetStatisticsResponse,
-  TransactionRuleControllerGetDetailData,
-  TransactionRuleControllerGetDetailResponse,
-  TransactionRuleController2Data,
-  TransactionRuleController2Response,
-  TransactionRuleController3Data,
-  TransactionRuleController3Response,
-  TransactionRuleControllerTestData,
-  TransactionRuleControllerTestResponse,
+  ReportingControllerGetPortfolioTrendsData,
+  ReportingControllerGetPortfolioTrendsResponse,
+  ReportingControllerGetCashFlowTrendsData,
+  ReportingControllerGetCashFlowTrendsResponse,
+  ReportingControllerGenerateSnapshotData,
+  ReportingControllerGenerateSnapshotResponse,
+  ReportingControllerBackfillSnapshotsData,
+  ReportingControllerBackfillSnapshotsResponse,
   UserControllerDeleteOwnUserData,
   UserControllerDeleteOwnUserResponse,
   UserControllerGetUserData,
@@ -157,106 +165,135 @@ import type {
   UserControllerUpdateUserSettingResponse,
   UserControllerGetAllUserSettingsByPageData,
   UserControllerGetAllUserSettingsByPageResponse,
-  UserControllerGetAssetLiabilitySummaryData,
   UserControllerGetAssetLiabilitySummaryResponse,
-  PropertyControllerGetAllData,
   PropertyControllerGetAllResponse,
   PropertyControllerGetByKeyData,
   PropertyControllerGetByKeyResponse,
-  PropertyControllerData,
-  PropertyControllerResponse,
-  PropertyController1Data,
-  PropertyController1Response,
+  PropertyControllerUpdateData,
+  PropertyControllerUpdateResponse,
+  PropertyControllerDeleteData,
+  PropertyControllerDeleteResponse,
+  TransactionRuleControllerCreateData,
+  TransactionRuleControllerCreateResponse,
+  TransactionRuleControllerListData,
+  TransactionRuleControllerListResponse,
+  TransactionRuleControllerValidateData,
+  TransactionRuleControllerValidateResponse,
+  TransactionRuleControllerBulkCreateData,
+  TransactionRuleControllerBulkCreateResponse,
+  TransactionRuleControllerExportData,
+  TransactionRuleControllerExportResponse,
+  TransactionRuleControllerGetStatisticsData,
+  TransactionRuleControllerGetStatisticsResponse,
+  TransactionRuleControllerGetDetailData,
+  TransactionRuleControllerGetDetailResponse,
+  TransactionRuleControllerUpdateData,
+  TransactionRuleControllerUpdateResponse,
+  TransactionRuleControllerDeleteData,
+  TransactionRuleControllerDeleteResponse,
+  TransactionRuleControllerTestData,
+  TransactionRuleControllerTestResponse,
+  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,
   FileImportControllerIdentifyFileData,
   FileImportControllerIdentifyFileResponse,
+  FileImportControllerImportBeancountData,
+  FileImportControllerImportBeancountResponse,
   ImporterConfigControllerGetConfigData,
   ImporterConfigControllerGetConfigResponse,
-  ImporterConfigControllerData,
-  ImporterConfigControllerResponse,
-  ImporterConfigController1Data,
-  ImporterConfigController1Response,
+  ImporterConfigControllerUpdateConfigData,
+  ImporterConfigControllerUpdateConfigResponse,
+  ImporterConfigControllerResetConfigData,
+  ImporterConfigControllerResetConfigResponse,
   ProviderSyncControllerSyncData,
   ProviderSyncControllerSyncResponse,
   ProviderSyncControllerGetSupportedProvidersData,
   ProviderSyncControllerGetSupportedProvidersResponse,
   ProviderSyncControllerIsProviderSupportedData,
   ProviderSyncControllerIsProviderSupportedResponse,
+  ExternalAccountLinkControllerCreateData,
+  ExternalAccountLinkControllerCreateResponse,
+  ExternalAccountLinkControllerFindAllData,
+  ExternalAccountLinkControllerFindAllResponse,
+  ExternalAccountLinkControllerFindOneData,
+  ExternalAccountLinkControllerFindOneResponse,
+  ExternalAccountLinkControllerRemoveData,
+  ExternalAccountLinkControllerRemoveResponse,
   TelemetryControllerReportTelemetryData,
   TelemetryControllerReportTelemetryResponse,
+  TelemetryControllerReportCoverageMissData,
+  TelemetryControllerReportCoverageMissResponse,
+  TelemetryControllerGetCoverageMetricsData,
+  TelemetryControllerGetCoverageMetricsResponse,
   NlpControllerProcessNaturalLanguageData,
   NlpControllerProcessNaturalLanguageResponse,
   NlpControllerClearSessionData,
   NlpControllerClearSessionResponse,
   NlpControllerGetSessionData,
   NlpControllerGetSessionResponse,
-  PlatformControllerFindAllData,
   PlatformControllerFindAllResponse,
-  PlatformControllerData,
-  PlatformControllerResponse,
+  PlatformControllerCreateData,
+  PlatformControllerCreateResponse,
   PlatformControllerGetPlatformListData,
   PlatformControllerGetPlatformListResponse,
-  PlatformController1Data,
-  PlatformController1Response,
-  PlatformController2Data,
-  PlatformController2Response,
-  SymbolControllerLookupSymbolData,
-  SymbolControllerLookupSymbolResponse,
-  SymbolControllerGetSymbolDataData,
-  SymbolControllerGetSymbolDataResponse,
-  SymbolControllerGatherSymbolForDateData,
-  SymbolControllerGatherSymbolForDateResponse,
-  SymbolControllerData,
-  SymbolControllerResponse,
-  CacheControllerFlushCacheData,
-  CacheControllerFlushCacheResponse,
+  PlatformControllerMatchPlatformsData,
+  PlatformControllerMatchPlatformsResponse,
+  PlatformControllerUpdateData,
+  PlatformControllerUpdateResponse,
+  PlatformControllerDeleteData,
+  PlatformControllerDeleteResponse,
   DashboardControllerGetNetWorthData,
   DashboardControllerGetNetWorthResponse,
   DashboardControllerGetAccountsData,
   DashboardControllerGetAccountsResponse,
   DashboardControllerGetCashFlowData,
   DashboardControllerGetCashFlowResponse,
-  ReportingControllerGetPortfolioTrendsData,
-  ReportingControllerGetPortfolioTrendsResponse,
-  ReportingControllerGenerateSnapshotData,
-  ReportingControllerGenerateSnapshotResponse,
-  ReportingControllerBackfillSnapshotsData,
-  ReportingControllerBackfillSnapshotsResponse,
-  ApiKeysControllerData,
-  ApiKeysControllerResponse,
+  DashboardControllerGetExpensesData,
+  DashboardControllerGetExpensesResponse,
+  HoldingPnlControllerGetHoldingPnlData,
+  HoldingPnlControllerGetHoldingPnlResponse,
+  ApiKeysControllerCreateApiKeyResponse,
   AuthControllerAccessTokenLoginData,
   AuthControllerAccessTokenLoginResponse,
+  CacheControllerFlushCacheResponse,
   ExchangeRateControllerGetExchangeRateData,
   ExchangeRateControllerGetExchangeRateResponse,
-  HealthControllerGetHealthData,
   HealthControllerGetHealthResponse,
-  HealthControllerCheckDatabaseData,
   HealthControllerCheckDatabaseResponse,
-  HealthControllerCheckRedisData,
+  HealthControllerCheckOpenBbResponse,
   HealthControllerCheckRedisResponse,
-  HealthControllerGetCircuitBreakersHealthData,
   HealthControllerGetCircuitBreakersHealthResponse,
   HealthControllerResetCircuitBreakerData,
   HealthControllerResetCircuitBreakerResponse,
-  HealthControllerGetMetricsData,
   HealthControllerGetMetricsResponse,
-  HealthControllerGetHealthOfDataEnhancerData,
-  HealthControllerGetHealthOfDataEnhancerResponse,
-  HealthControllerCheckDataProvidersData,
-  HealthControllerCheckDataProvidersResponse,
-  HealthControllerGetHealthOfDataProviderData,
-  HealthControllerGetHealthOfDataProviderResponse,
-  InfoControllerGetInfoData,
   InfoControllerGetInfoResponse,
-  LogoControllerGetLogoByDataSourceAndSymbolData,
-  LogoControllerGetLogoByDataSourceAndSymbolResponse,
-  LogoControllerGetLogoByUrlData,
-  LogoControllerGetLogoByUrlResponse,
-  MarketDataControllerGetMarketDataBySymbolData,
-  MarketDataControllerGetMarketDataBySymbolResponse,
-  MarketDataControllerData,
-  MarketDataControllerResponse
+  SymbolControllerSearchData,
+  SymbolControllerSearchResponse,
+  SymbolControllerGetQuoteData,
+  SymbolControllerGetQuoteResponse
 } from './types.gen';
 
 export class BeanAccountsService {
@@ -294,7 +331,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
@@ -375,7 +412,7 @@ export class BeanAccountsService {
 
   /**
    * Delete account
-   * Deletes an account (only if no transactions)
+   * 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 Account UUID
    * @param data.region Region code for tenant context
@@ -394,7 +431,7 @@ export class BeanAccountsService {
       },
       errors: {
         404: 'Account not found',
-        409: 'Account has transactions and cannot be deleted'
+        409: 'Account has active transactions and cannot be deleted'
       }
     });
   }
@@ -456,6 +493,107 @@ export class BeanAccountsService {
       }
     });
   }
+
+  /**
+   * 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'
+      }
+    });
+  }
+}
+
+export class BeanAccountStandardsService {
+  /**
+   * Get account templates
+   * Returns predefined account templates for a region. Supports filtering by account type and search term.
+   * @param data The data for the request.
+   * @param data.region Region code (cn, us, de)
+   * @param data.type Filter by account type
+   * @param data.search Search term for path or description
+   * @returns AccountStandardListResponseDto Account templates retrieved successfully
+   * @throws ApiError
+   */
+  public static accountStandardsControllerGetTemplates(
+    data: AccountStandardsControllerGetTemplatesData
+  ): CancelablePromise<AccountStandardsControllerGetTemplatesResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/bean/account-standards',
+      path: {
+        region: data.region
+      },
+      query: {
+        type: data.type,
+        search: data.search
+      }
+    });
+  }
+
+  /**
+   * Get template metadata for an account 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.path Account path to check
+   * @returns TemplateMetadataResponseDto Template metadata retrieved successfully
+   * @throws ApiError
+   */
+  public static accountStandardsControllerGetTemplateMetadata(
+    data: AccountStandardsControllerGetTemplateMetadataData
+  ): CancelablePromise<AccountStandardsControllerGetTemplateMetadataResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/bean/account-standards/template-metadata',
+      path: {
+        region: data.region
+      },
+      query: {
+        path: data.path
+      }
+    });
+  }
+
+  /**
+   * Get available regions with hierarchy
+   * Returns supported regions with inheritance metadata
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @returns RegionsMetadataResponseDto Regions metadata retrieved successfully
+   * @throws ApiError
+   */
+  public static accountStandardsControllerGetRegions(
+    data: AccountStandardsControllerGetRegionsData
+  ): CancelablePromise<AccountStandardsControllerGetRegionsResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/bean/account-standards/regions',
+      path: {
+        region: data.region
+      }
+    });
+  }
 }
 
 export class BeanTransactionsService {
@@ -501,6 +639,7 @@ export class BeanTransactionsService {
    * @param data.status Filter by transaction status
    * @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 Expenses/Income account whose derived Group segment equals this value
    * @returns TransactionListResponseDto Transaction list
    * @throws ApiError
    */
@@ -520,28 +659,102 @@ export class BeanTransactionsService {
         dateTo: data.dateTo,
         status: data.status,
         search: data.search,
-        accountId: data.accountId
+        accountId: data.accountId,
+        category: data.category
       },
       errors: {
+        400: 'Validation failed',
         401: 'Authentication required'
       }
     });
   }
 
   /**
+   * @deprecated
+   * Batch create transactions (DEPRECATED)
+   * DEPRECATED: Use POST /:region/bean/import/provider/:name/sync instead. This endpoint skips dedup, rule matching, and review branching.
    * @param data The data for the request.
    * @param data.region Region code for tenant context
-   * @returns unknown
+   * @param data.requestBody
+   * @returns BatchTransactionResponseDto Transactions processed
    * @throws ApiError
    */
-  public static transactionController(
-    data: TransactionControllerData
-  ): CancelablePromise<TransactionControllerResponse> {
+  public static transactionControllerCreateBatch(
+    data: TransactionControllerCreateBatchData
+  ): CancelablePromise<TransactionControllerCreateBatchResponse> {
     return __request(OpenAPI, {
       method: 'POST',
       url: '/api/v1/{region}/bean/transactions/batch',
       path: {
         region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: 'Invalid input',
+        401: 'Authentication required'
+      }
+    });
+  }
+
+  /**
+   * Correct (supersede) a transaction
+   * Atomically voids the original (SUPERSEDED) and creates a replacement through the full validation pipeline.
+   * @param data The data for the request.
+   * @param data.id Original transaction ID to correct
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns TransactionDetailDto Corrected transaction created
+   * @throws ApiError
+   */
+  public static transactionControllerCorrect(
+    data: TransactionControllerCorrectData
+  ): CancelablePromise<TransactionControllerCorrectResponse> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/{region}/bean/transactions/{id}/correct',
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        404: 'Original transaction not found',
+        409: 'Original no longer ACTIVE (concurrent modification)',
+        422: 'Pipeline validation failed (does not balance, invalid accounts)'
+      }
+    });
+  }
+
+  /**
+   * Suggest transaction tags
+   * Returns distinct tags from the user ACTIVE transactions, sorted by usage, for autocomplete. Optional q performs a case-insensitive prefix match.
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @param data.q Prefix match, case-insensitive (max 50 chars)
+   * @param data.sort usage (default) or name
+   * @param data.limit Max suggestions (1-100, default 10)
+   * @returns TagSuggestionsResponseDto Tag suggestions
+   * @throws ApiError
+   */
+  public static transactionControllerSuggestTags(
+    data: TransactionControllerSuggestTagsData
+  ): CancelablePromise<TransactionControllerSuggestTagsResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/bean/transactions/tags',
+      path: {
+        region: data.region
+      },
+      query: {
+        q: data.q,
+        sort: data.sort,
+        limit: data.limit
+      },
+      errors: {
+        400: 'Validation failed',
+        401: 'Authentication required'
       }
     });
   }
@@ -603,67 +816,28 @@ export class BeanTransactionsService {
   }
 
   /**
+   * Void transaction
+   * Soft-deletes a transaction by marking it as VOIDED
    * @param data The data for the request.
+   * @param data.id Transaction ID
    * @param data.region Region code for tenant context
-   * @returns void
+   * @returns void Transaction voided successfully
    * @throws ApiError
    */
-  public static transactionController1(
-    data: TransactionController1Data
-  ): CancelablePromise<TransactionController1Response> {
+  public static transactionControllerDelete(
+    data: TransactionControllerDeleteData
+  ): CancelablePromise<TransactionControllerDeleteResponse> {
     return __request(OpenAPI, {
       method: 'DELETE',
       url: '/api/v1/{region}/bean/transactions/{id}',
       path: {
-        region: data.region
-      }
-    });
-  }
-}
-
-export class BeanAccountStandardsService {
-  /**
-   * Get account templates
-   * Returns predefined account templates for a region. Supports filtering by account type and search term.
-   * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @param data.type Filter by account type
-   * @param data.search Search term for path or description
-   * @returns AccountStandardListResponseDto Account templates retrieved successfully
-   * @throws ApiError
-   */
-  public static accountStandardsControllerGetTemplates(
-    data: AccountStandardsControllerGetTemplatesData
-  ): CancelablePromise<AccountStandardsControllerGetTemplatesResponse> {
-    return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/{region}/bean/account-standards',
-      path: {
+        id: data.id,
         region: data.region
       },
-      query: {
-        type: data.type,
-        search: data.search
-      }
-    });
-  }
-
-  /**
-   * Get available regions with hierarchy
-   * Returns supported regions with inheritance metadata
-   * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns RegionsMetadataResponseDto Regions metadata retrieved successfully
-   * @throws ApiError
-   */
-  public static accountStandardsControllerGetRegions(
-    data: AccountStandardsControllerGetRegionsData
-  ): CancelablePromise<AccountStandardsControllerGetRegionsResponse> {
-    return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/{region}/bean/account-standards/regions',
-      path: {
-        region: data.region
+      errors: {
+        400: 'Transaction already voided',
+        401: 'Authentication required',
+        404: 'Transaction not found'
       }
     });
   }
@@ -674,8 +848,8 @@ 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.region Region code (cn, us, de)
+   * @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")
    * @returns BalanceResponseDto Balance calculated successfully
@@ -706,7 +880,7 @@ export class BeanBalancesService {
    * Query multi-currency account balance
    * Calculate account balances for all currencies at a specific date
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
+   * @param data.region Region code for tenant context
    * @returns MultiCurrencyBalanceResponseDto Balances calculated successfully
    * @throws ApiError
    */
@@ -731,7 +905,7 @@ export class BeanReviewsService {
   /**
    * List pending reviews
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
+   * @param data.region Region code for tenant context
    * @param data.type Filter by review type
    * @param data.confidenceLevel Filter by confidence level
    * @param data.sortBy Sort order
@@ -762,7 +936,7 @@ export class BeanReviewsService {
   /**
    * Get review statistics
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
+   * @param data.region Region code for tenant context
    * @returns ReviewStatsDto
    * @throws ApiError
    */
@@ -782,7 +956,7 @@ export class BeanReviewsService {
    * Get review by ID
    * @param data The data for the request.
    * @param data.id Review ID
-   * @param data.region Region code (cn, us, de)
+   * @param data.region Region code for tenant context
    * @returns ReviewDetailDto
    * @throws ApiError
    */
@@ -800,75 +974,93 @@ export class BeanReviewsService {
   }
 
   /**
+   * Resolve a review item
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.id Review ID
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns ResolveResultDto
    * @throws ApiError
    */
-  public static reviewController(
-    data: ReviewControllerData
-  ): CancelablePromise<ReviewControllerResponse> {
+  public static reviewControllerResolve(
+    data: ReviewControllerResolveData
+  ): CancelablePromise<ReviewControllerResolveResponse> {
     return __request(OpenAPI, {
       method: 'POST',
       url: '/api/v1/{region}/bean/reviews/{id}/resolve',
       path: {
+        id: data.id,
         region: data.region
-      }
+      },
+      body: data.requestBody,
+      mediaType: 'application/json'
     });
   }
 
   /**
+   * Undo a resolution (within 24h)
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
-   * @throws ApiError
+   * @param data.id Review ID
+   * @param data.region Region code for tenant context
+   * @returns UndoResultDto
+   * @throws ApiError
    */
-  public static reviewController1(
-    data: ReviewController1Data
-  ): CancelablePromise<ReviewController1Response> {
+  public static reviewControllerUndo(
+    data: ReviewControllerUndoData
+  ): CancelablePromise<ReviewControllerUndoResponse> {
     return __request(OpenAPI, {
       method: 'POST',
       url: '/api/v1/{region}/bean/reviews/{id}/undo',
       path: {
+        id: data.id,
         region: data.region
       }
     });
   }
 
   /**
+   * Batch resolve multiple reviews
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.region Region code for tenant context
+   * @param data.requestBody Batch resolution request containing review IDs and action
+   * @returns BatchResolveResultDto
    * @throws ApiError
    */
-  public static reviewController2(
-    data: ReviewController2Data
-  ): CancelablePromise<ReviewController2Response> {
+  public static reviewControllerBatchResolve(
+    data: ReviewControllerBatchResolveData
+  ): CancelablePromise<ReviewControllerBatchResolveResponse> {
     return __request(OpenAPI, {
       method: 'POST',
       url: '/api/v1/{region}/bean/reviews/batch-resolve',
       path: {
         region: data.region
-      }
+      },
+      body: data.requestBody,
+      mediaType: 'application/json'
     });
   }
 }
 
 export class BeanPayeesService {
   /**
+   * Create a new payee
+   * Creates a new payee mapping for the authenticated user. The payee name must be unique within the user's account.
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.requestBody
+   * @returns PayeeResponseDto Payee created successfully
    * @throws ApiError
    */
-  public static payeeController(
-    data: PayeeControllerData
-  ): CancelablePromise<PayeeControllerResponse> {
+  public static payeeControllerCreate(
+    data: PayeeControllerCreateData
+  ): CancelablePromise<PayeeControllerCreateResponse> {
     return __request(OpenAPI, {
       method: 'POST',
       url: '/api/v1/bean/payees',
-      path: {
-        region: data.region
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: 'Invalid input data',
+        409: 'Payee already exists'
       }
     });
   }
@@ -877,7 +1069,6 @@ export class BeanPayeesService {
    * List user payees
    * Returns all payee mappings for the authenticated user with optional filtering
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
    * @param data.search Search term for payee name (partial match, case-insensitive). Useful for autocomplete.
    * @param data.payee Filter by exact payee name match
    * @param data.category Filter by custom category
@@ -887,14 +1078,11 @@ export class BeanPayeesService {
    * @throws ApiError
    */
   public static payeeControllerFindAll(
-    data: PayeeControllerFindAllData
+    data: PayeeControllerFindAllData = {}
   ): CancelablePromise<PayeeControllerFindAllResponse> {
     return __request(OpenAPI, {
       method: 'GET',
       url: '/api/v1/bean/payees',
-      path: {
-        region: data.region
-      },
       query: {
         search: data.search,
         payee: data.payee,
@@ -910,7 +1098,6 @@ export class BeanPayeesService {
    * Returns active payee names matching the query, sorted by recent usage. Used for transaction input autocomplete.
    * @param data The data for the request.
    * @param data.q Search query for payee name (partial match, case-insensitive)
-   * @param data.region Region code (cn, us, de)
    * @param data.limit Maximum number of suggestions
    * @returns PayeeAutocompleteResponseDto Autocomplete suggestions retrieved successfully
    * @throws ApiError
@@ -921,9 +1108,6 @@ export class BeanPayeesService {
     return __request(OpenAPI, {
       method: 'GET',
       url: '/api/v1/bean/payees/autocomplete',
-      path: {
-        region: data.region
-      },
       query: {
         q: data.q,
         limit: data.limit
@@ -935,20 +1119,16 @@ export class BeanPayeesService {
    * Get top payees by usage
    * Returns the most frequently used payees, sorted by use count. Used for statistics and analytics.
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
    * @param data.limit Maximum number of results
    * @returns PayeeStatsResponseDto Top payees retrieved successfully
    * @throws ApiError
    */
   public static payeeControllerGetTopPayees(
-    data: PayeeControllerGetTopPayeesData
+    data: PayeeControllerGetTopPayeesData = {}
   ): CancelablePromise<PayeeControllerGetTopPayeesResponse> {
     return __request(OpenAPI, {
       method: 'GET',
       url: '/api/v1/bean/payees/top',
-      path: {
-        region: data.region
-      },
       query: {
         limit: data.limit
       }
@@ -960,7 +1140,6 @@ export class BeanPayeesService {
    * Returns a specific payee mapping by its UUID
    * @param data The data for the request.
    * @param data.id Payee UUID
-   * @param data.region Region code (cn, us, de)
    * @returns PayeeResponseDto Payee retrieved successfully
    * @throws ApiError
    */
@@ -971,8 +1150,7 @@ export class BeanPayeesService {
       method: 'GET',
       url: '/api/v1/bean/payees/{id}',
       path: {
-        id: data.id,
-        region: data.region
+        id: data.id
       },
       errors: {
         403: 'Payee belongs to another user',
@@ -982,37 +1160,51 @@ export class BeanPayeesService {
   }
 
   /**
+   * Update payee
+   * Updates a payee mapping. The payee name cannot be changed after creation.
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.id Payee UUID
+   * @param data.requestBody
+   * @returns PayeeResponseDto Payee updated successfully
    * @throws ApiError
    */
-  public static payeeController1(
-    data: PayeeController1Data
-  ): CancelablePromise<PayeeController1Response> {
+  public static payeeControllerUpdate(
+    data: PayeeControllerUpdateData
+  ): CancelablePromise<PayeeControllerUpdateResponse> {
     return __request(OpenAPI, {
       method: 'PUT',
       url: '/api/v1/bean/payees/{id}',
       path: {
-        region: data.region
+        id: data.id
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: 'Invalid input data',
+        404: 'Payee not found'
       }
     });
   }
 
   /**
+   * Delete payee
+   * Soft deletes a payee by marking it as inactive. Inactive payees will not appear in autocomplete suggestions.
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns void
+   * @param data.id Payee UUID
+   * @returns void Payee deleted successfully
    * @throws ApiError
    */
-  public static payeeController2(
-    data: PayeeController2Data
-  ): CancelablePromise<PayeeController2Response> {
+  public static payeeControllerDelete(
+    data: PayeeControllerDeleteData
+  ): CancelablePromise<PayeeControllerDeleteResponse> {
     return __request(OpenAPI, {
       method: 'DELETE',
       url: '/api/v1/bean/payees/{id}',
       path: {
-        region: data.region
+        id: data.id
+      },
+      errors: {
+        404: 'Payee not found'
       }
     });
   }
@@ -1020,19 +1212,25 @@ export class BeanPayeesService {
 
 export class AdminPayeeProfilesService {
   /**
+   * Create payee profile (Admin only)
+   * Creates a new global payee profile. The canonical name must be unique (case-insensitive).
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.requestBody
+   * @returns PayeeProfileResponseDto Payee profile created successfully
    * @throws ApiError
    */
-  public static payeeProfileAdminController(
-    data: PayeeProfileAdminControllerData
-  ): CancelablePromise<PayeeProfileAdminControllerResponse> {
+  public static payeeProfileAdminControllerCreate(
+    data: PayeeProfileAdminControllerCreateData
+  ): CancelablePromise<PayeeProfileAdminControllerCreateResponse> {
     return __request(OpenAPI, {
       method: 'POST',
       url: '/api/v1/admin/payee-profiles',
-      path: {
-        region: data.region
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: 'Validation failed',
+        403: 'Admin access required',
+        409: 'Payee profile already exists'
       }
     });
   }
@@ -1041,7 +1239,6 @@ export class AdminPayeeProfilesService {
    * List payee profiles (Admin only)
    * Returns all payee profiles with optional filtering by category, country, verification status, etc.
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
    * @param data.search Search term for canonical name and aliases (case-insensitive)
    * @param data.category Filter by category
    * @param data.country Filter by country (ISO 3166-1 alpha-2)
@@ -1052,14 +1249,11 @@ export class AdminPayeeProfilesService {
    * @throws ApiError
    */
   public static payeeProfileAdminControllerFindAll(
-    data: PayeeProfileAdminControllerFindAllData
+    data: PayeeProfileAdminControllerFindAllData = {}
   ): CancelablePromise<PayeeProfileAdminControllerFindAllResponse> {
     return __request(OpenAPI, {
       method: 'GET',
       url: '/api/v1/admin/payee-profiles',
-      path: {
-        region: data.region
-      },
       query: {
         search: data.search,
         category: data.category,
@@ -1079,7 +1273,6 @@ export class AdminPayeeProfilesService {
    * Returns a single payee profile by its ID.
    * @param data The data for the request.
    * @param data.id Payee profile ID (UUID)
-   * @param data.region Region code (cn, us, de)
    * @returns PayeeProfileResponseDto Payee profile retrieved successfully
    * @throws ApiError
    */
@@ -1090,8 +1283,7 @@ export class AdminPayeeProfilesService {
       method: 'GET',
       url: '/api/v1/admin/payee-profiles/{id}',
       path: {
-        id: data.id,
-        region: data.region
+        id: data.id
       },
       errors: {
         403: 'Admin access required',
@@ -1101,73 +1293,101 @@ export class AdminPayeeProfilesService {
   }
 
   /**
+   * Update payee profile (Admin only)
+   * Updates an existing payee profile. The canonical name cannot be changed.
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.id Payee profile ID (UUID)
+   * @param data.requestBody
+   * @returns PayeeProfileResponseDto Payee profile updated successfully
    * @throws ApiError
    */
-  public static payeeProfileAdminController1(
-    data: PayeeProfileAdminController1Data
-  ): CancelablePromise<PayeeProfileAdminController1Response> {
+  public static payeeProfileAdminControllerUpdate(
+    data: PayeeProfileAdminControllerUpdateData
+  ): CancelablePromise<PayeeProfileAdminControllerUpdateResponse> {
     return __request(OpenAPI, {
       method: 'PUT',
       url: '/api/v1/admin/payee-profiles/{id}',
       path: {
-        region: data.region
+        id: data.id
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        403: 'Admin access required',
+        404: 'Payee profile not found'
       }
     });
   }
 
   /**
+   * Soft delete payee profile (Admin only)
+   * Marks a payee profile as inactive (soft delete). The profile cannot be deleted if it is referenced by user payees.
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns void
+   * @param data.id Payee profile ID (UUID)
+   * @returns void Payee profile deleted successfully
    * @throws ApiError
    */
-  public static payeeProfileAdminController2(
-    data: PayeeProfileAdminController2Data
-  ): CancelablePromise<PayeeProfileAdminController2Response> {
+  public static payeeProfileAdminControllerDelete(
+    data: PayeeProfileAdminControllerDeleteData
+  ): CancelablePromise<PayeeProfileAdminControllerDeleteResponse> {
     return __request(OpenAPI, {
       method: 'DELETE',
       url: '/api/v1/admin/payee-profiles/{id}',
       path: {
-        region: data.region
+        id: data.id
+      },
+      errors: {
+        403: 'Admin access required',
+        404: 'Payee profile not found',
+        409: 'Payee profile is in use and cannot be deleted'
       }
     });
   }
 
   /**
+   * Verify payee profile (Admin only)
+   * Marks a payee profile as verified by setting verifiedAt to current timestamp.
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.id Payee profile ID (UUID)
+   * @returns PayeeProfileResponseDto Payee profile verified successfully
    * @throws ApiError
    */
-  public static payeeProfileAdminController3(
-    data: PayeeProfileAdminController3Data
-  ): CancelablePromise<PayeeProfileAdminController3Response> {
+  public static payeeProfileAdminControllerVerify(
+    data: PayeeProfileAdminControllerVerifyData
+  ): CancelablePromise<PayeeProfileAdminControllerVerifyResponse> {
     return __request(OpenAPI, {
       method: 'POST',
       url: '/api/v1/admin/payee-profiles/{id}/verify',
       path: {
-        region: data.region
+        id: data.id
+      },
+      errors: {
+        403: 'Admin access required',
+        404: 'Payee profile not found'
       }
     });
   }
 
   /**
+   * Unverify payee profile (Admin only)
+   * Removes verification status by setting verifiedAt to null.
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.id Payee profile ID (UUID)
+   * @returns PayeeProfileResponseDto Payee profile unverified successfully
    * @throws ApiError
    */
-  public static payeeProfileAdminController4(
-    data: PayeeProfileAdminController4Data
-  ): CancelablePromise<PayeeProfileAdminController4Response> {
+  public static payeeProfileAdminControllerUnverify(
+    data: PayeeProfileAdminControllerUnverifyData
+  ): CancelablePromise<PayeeProfileAdminControllerUnverifyResponse> {
     return __request(OpenAPI, {
       method: 'DELETE',
       url: '/api/v1/admin/payee-profiles/{id}/verify',
       path: {
-        region: data.region
+        id: data.id
+      },
+      errors: {
+        403: 'Admin access required',
+        404: 'Payee profile not found'
       }
     });
   }
@@ -1175,19 +1395,28 @@ export class AdminPayeeProfilesService {
 
 export class BeanCommoditiesService {
   /**
+   * Create a new commodity
+   * Creates a new commodity definition for the authenticated user
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns CommodityResponseDto Commodity created successfully
    * @throws ApiError
    */
-  public static commodityController(
-    data: CommodityControllerData
-  ): CancelablePromise<CommodityControllerResponse> {
+  public static commodityControllerCreate(
+    data: CommodityControllerCreateData
+  ): CancelablePromise<CommodityControllerCreateResponse> {
     return __request(OpenAPI, {
       method: 'POST',
       url: '/api/v1/{region}/bean/commodities',
       path: {
         region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: 'Invalid input data',
+        409: 'Commodity already exists'
       }
     });
   }
@@ -1196,7 +1425,7 @@ export class BeanCommoditiesService {
    * List user commodities
    * Returns all commodity definitions for the authenticated user with optional filtering
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
+   * @param data.region Region code for tenant context
    * @param data.search Search term for symbol or metadata fields (partial match). Searches symbol and metadata.name.
    * @param data.symbol Filter by exact symbol match
    * @returns CommodityListResponseDto Commodities retrieved successfully
@@ -1223,7 +1452,7 @@ export class BeanCommoditiesService {
    * Returns a specific commodity definition by its symbol
    * @param data The data for the request.
    * @param data.symbol Commodity symbol
-   * @param data.region Region code (cn, us, de)
+   * @param data.region Region code for tenant context
    * @returns CommodityResponseDto Commodity retrieved successfully
    * @throws ApiError
    */
@@ -1244,68 +1473,92 @@ export class BeanCommoditiesService {
   }
 
   /**
+   * Update commodity
+   * Updates an existing commodity definition. Symbol cannot be changed.
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.symbol Commodity symbol
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns CommodityResponseDto Commodity updated successfully
    * @throws ApiError
    */
-  public static commodityController1(
-    data: CommodityController1Data
-  ): CancelablePromise<CommodityController1Response> {
+  public static commodityControllerUpdate(
+    data: CommodityControllerUpdateData
+  ): CancelablePromise<CommodityControllerUpdateResponse> {
     return __request(OpenAPI, {
       method: 'PUT',
       url: '/api/v1/{region}/bean/commodities/{symbol}',
       path: {
+        symbol: data.symbol,
         region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: 'Invalid input data',
+        404: 'Commodity not found'
       }
     });
   }
 
   /**
+   * Delete commodity
+   * Deletes a commodity definition
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns void
+   * @param data.symbol Commodity symbol
+   * @param data.region Region code for tenant context
+   * @returns void Commodity deleted successfully
    * @throws ApiError
    */
-  public static commodityController2(
-    data: CommodityController2Data
-  ): CancelablePromise<CommodityController2Response> {
+  public static commodityControllerDelete(
+    data: CommodityControllerDeleteData
+  ): CancelablePromise<CommodityControllerDeleteResponse> {
     return __request(OpenAPI, {
       method: 'DELETE',
       url: '/api/v1/{region}/bean/commodities/{symbol}',
       path: {
+        symbol: data.symbol,
         region: data.region
+      },
+      errors: {
+        404: 'Commodity not found'
       }
     });
   }
 
   /**
+   * Ensure commodity exists
+   * Gets existing commodity or creates it with automatic initialization from OpenBB
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.symbol Commodity symbol
+   * @param data.region Region code for tenant context
+   * @returns CommodityResponseDto Commodity retrieved or created
    * @throws ApiError
    */
-  public static commodityController3(
-    data: CommodityController3Data
-  ): CancelablePromise<CommodityController3Response> {
+  public static commodityControllerGetOrCreate(
+    data: CommodityControllerGetOrCreateData
+  ): CancelablePromise<CommodityControllerGetOrCreateResponse> {
     return __request(OpenAPI, {
       method: 'POST',
       url: '/api/v1/{region}/bean/commodities/{symbol}/ensure',
       path: {
+        symbol: data.symbol,
         region: data.region
       }
     });
   }
 
   /**
+   * Bulk create commodities
+   * Creates multiple commodities from a list of symbols, useful for initialization
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.region Region code for tenant context
+   * @returns CommodityResponseDto Commodities created successfully
    * @throws ApiError
    */
-  public static commodityController4(
-    data: CommodityController4Data
-  ): CancelablePromise<CommodityController4Response> {
+  public static commodityControllerBulkCreate(
+    data: CommodityControllerBulkCreateData
+  ): CancelablePromise<CommodityControllerBulkCreateResponse> {
     return __request(OpenAPI, {
       method: 'POST',
       url: '/api/v1/{region}/bean/commodities/bulk',
@@ -1316,182 +1569,387 @@ export class BeanCommoditiesService {
   }
 }
 
-export class RecurringRulesService {
+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 (cn, us, de)
-   * @returns unknown
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns PriceResponseDto Price created successfully
    * @throws ApiError
    */
-  public static recurringRuleController(
-    data: RecurringRuleControllerData
-  ): CancelablePromise<RecurringRuleControllerResponse> {
+  public static priceControllerCreate(
+    data: PriceControllerCreateData
+  ): CancelablePromise<PriceControllerCreateResponse> {
     return __request(OpenAPI, {
       method: 'POST',
-      url: '/api/v1/{region}/bean/recurring-rules',
+      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 recurring rules
-   * Returns all recurring rules for the authenticated user with optional filtering
+   * 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 (cn, us, de)
-   * @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.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 recurringRuleControllerFindAll(
-    data: RecurringRuleControllerFindAllData
-  ): CancelablePromise<RecurringRuleControllerFindAllResponse> {
+  public static priceControllerFindAll(
+    data: PriceControllerFindAllData
+  ): CancelablePromise<PriceControllerFindAllResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/{region}/bean/recurring-rules',
+      url: '/api/v1/{region}/bean/prices',
       path: {
         region: data.region
       },
       query: {
-        isActive: data.isActive,
-        frequency: data.frequency,
-        hasAutoCreate: data.hasAutoCreate
+        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.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.id Price ID
+   * @param data.region Region code for tenant context
+   * @returns PriceResponseDto Price retrieved successfully
    * @throws ApiError
    */
-  public static recurringRuleController1(
-    data: RecurringRuleController1Data
-  ): CancelablePromise<RecurringRuleController1Response> {
+  public static priceControllerFindOne(
+    data: PriceControllerFindOneData
+  ): CancelablePromise<PriceControllerFindOneResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/{region}/bean/recurring-rules/from-transaction/{transactionId}',
+      method: 'GET',
+      url: '/api/v1/{region}/bean/prices/{id}',
       path: {
+        id: data.id,
         region: data.region
+      },
+      errors: {
+        404: 'Price not found'
       }
     });
   }
 
   /**
-   * Get recurring rule by ID
-   * Returns a specific recurring rule with its details
+   * Update a price
+   * Updates an existing price entry
    * @param data The data for the request.
-   * @param data.id Rule ID
-   * @param data.region Region code (cn, us, de)
-   * @returns RecurringRuleResponseDto Rule retrieved successfully
+   * @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 recurringRuleControllerFindOne(
-    data: RecurringRuleControllerFindOneData
-  ): CancelablePromise<RecurringRuleControllerFindOneResponse> {
+  public static priceControllerUpdate(
+    data: PriceControllerUpdateData
+  ): CancelablePromise<PriceControllerUpdateResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/{region}/bean/recurring-rules/{id}',
+      method: 'PUT',
+      url: '/api/v1/{region}/bean/prices/{id}',
       path: {
         id: data.id,
         region: data.region
       },
+      body: data.requestBody,
+      mediaType: 'application/json',
       errors: {
-        404: 'Rule not found'
+        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.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.id Price ID
+   * @param data.region Region code for tenant context
+   * @returns void Price deleted successfully
    * @throws ApiError
    */
-  public static recurringRuleController2(
-    data: RecurringRuleController2Data
-  ): CancelablePromise<RecurringRuleController2Response> {
+  public static priceControllerDelete(
+    data: PriceControllerDeleteData
+  ): CancelablePromise<PriceControllerDeleteResponse> {
     return __request(OpenAPI, {
-      method: 'PATCH',
-      url: '/api/v1/{region}/bean/recurring-rules/{id}',
+      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 (cn, us, de)
-   * @returns void
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns PriceResponseDto Prices created successfully
    * @throws ApiError
    */
-  public static recurringRuleController3(
-    data: RecurringRuleController3Data
-  ): CancelablePromise<RecurringRuleController3Response> {
+  public static priceControllerBulkCreate(
+    data: PriceControllerBulkCreateData
+  ): CancelablePromise<PriceControllerBulkCreateResponse> {
     return __request(OpenAPI, {
-      method: 'DELETE',
-      url: '/api/v1/{region}/bean/recurring-rules/{id}',
+      method: 'POST',
+      url: '/api/v1/{region}/bean/prices/bulk',
       path: {
         region: data.region
-      }
+      },
+      body: data.requestBody,
+      mediaType: 'application/json'
     });
   }
+}
 
+export class RecurringRulesService {
   /**
-   * Get rule with statistics
-   * Returns a rule with pending/overdue counts and next expected date
+   * Create a new recurring rule
+   * Creates a new recurring transaction rule for the authenticated user
    * @param data The data for the request.
-   * @param data.id Rule ID
-   * @param data.region Region code (cn, us, de)
-   * @returns RecurringRuleWithStatsResponseDto Rule with stats retrieved successfully
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns RecurringRuleResponseDto Rule created successfully
    * @throws ApiError
    */
-  public static recurringRuleControllerGetWithStats(
-    data: RecurringRuleControllerGetWithStatsData
-  ): CancelablePromise<RecurringRuleControllerGetWithStatsResponse> {
+  public static recurringRuleControllerCreate(
+    data: RecurringRuleControllerCreateData
+  ): CancelablePromise<RecurringRuleControllerCreateResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/{region}/bean/recurring-rules/{id}/stats',
+      method: 'POST',
+      url: '/api/v1/{region}/bean/recurring-rules',
       path: {
-        id: data.id,
         region: data.region
       },
+      body: data.requestBody,
+      mediaType: 'application/json',
       errors: {
-        404: 'Rule not found'
+        400: 'Invalid input data (e.g., autoCreate without accounts)',
+        409: 'Rule with same name already exists'
       }
     });
   }
-}
 
-export class ExpectedTransactionsService {
   /**
-   * List expected transactions
-   * Returns expected transactions for the authenticated user with optional filtering
+   * 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 (cn, us, de)
-   * @param data.ruleId Filter by recurring rule ID
-   * @param data.status Filter by status (PENDING, COMPLETED, SKIPPED)
-   * @param data.fromDate Filter by date range start (YYYY-MM-DD)
-   * @param data.toDate Filter by date range end (YYYY-MM-DD)
-   * @returns ExpectedTransactionListResponseDto Expected transactions retrieved successfully
+   * @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 expectedTransactionControllerFindAll(
-    data: ExpectedTransactionControllerFindAllData
-  ): CancelablePromise<ExpectedTransactionControllerFindAllResponse> {
+  public static recurringRuleControllerFindAll(
+    data: RecurringRuleControllerFindAllData
+  ): CancelablePromise<RecurringRuleControllerFindAllResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/{region}/bean/expected-transactions',
+      url: '/api/v1/{region}/bean/recurring-rules',
       path: {
         region: data.region
       },
       query: {
-        ruleId: data.ruleId,
+        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
+   */
+  public static recurringRuleControllerFindOne(
+    data: RecurringRuleControllerFindOneData
+  ): CancelablePromise<RecurringRuleControllerFindOneResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/bean/recurring-rules/{id}',
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      errors: {
+        404: 'Rule not found'
+      }
+    });
+  }
+
+  /**
+   * Update recurring rule
+   * Updates an existing recurring rule
+   * @param data The data for the request.
+   * @param data.id Rule ID
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns RecurringRuleResponseDto Rule updated successfully
+   * @throws ApiError
+   */
+  public static recurringRuleControllerUpdate(
+    data: RecurringRuleControllerUpdateData
+  ): CancelablePromise<RecurringRuleControllerUpdateResponse> {
+    return __request(OpenAPI, {
+      method: 'PATCH',
+      url: '/api/v1/{region}/bean/recurring-rules/{id}',
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: 'Invalid input data',
+        404: 'Rule not found'
+      }
+    });
+  }
+
+  /**
+   * Delete recurring rule
+   * Soft deletes a recurring rule (sets isActive to false)
+   * @param data The data for the request.
+   * @param data.id Rule ID
+   * @param data.region Region code for tenant context
+   * @returns void Rule deleted successfully
+   * @throws ApiError
+   */
+  public static recurringRuleControllerDelete(
+    data: RecurringRuleControllerDeleteData
+  ): CancelablePromise<RecurringRuleControllerDeleteResponse> {
+    return __request(OpenAPI, {
+      method: 'DELETE',
+      url: '/api/v1/{region}/bean/recurring-rules/{id}',
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      errors: {
+        404: 'Rule not found'
+      }
+    });
+  }
+
+  /**
+   * Get rule with statistics
+   * Returns a rule with pending/overdue counts and next expected date
+   * @param data The data for the request.
+   * @param data.id Rule ID
+   * @param data.region Region code for tenant context
+   * @returns RecurringRuleWithStatsResponseDto Rule with stats retrieved successfully
+   * @throws ApiError
+   */
+  public static recurringRuleControllerGetWithStats(
+    data: RecurringRuleControllerGetWithStatsData
+  ): CancelablePromise<RecurringRuleControllerGetWithStatsResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/bean/recurring-rules/{id}/stats',
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      errors: {
+        404: 'Rule not found'
+      }
+    });
+  }
+}
+
+export class ExpectedTransactionsService {
+  /**
+   * List expected transactions
+   * Returns expected transactions for the authenticated user with optional filtering
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @param data.ruleId Filter by recurring rule ID
+   * @param data.status Filter by status (PENDING, COMPLETED, SKIPPED)
+   * @param data.fromDate Filter by date range start (YYYY-MM-DD)
+   * @param data.toDate Filter by date range end (YYYY-MM-DD)
+   * @returns ExpectedTransactionListResponseDto Expected transactions retrieved successfully
+   * @throws ApiError
+   */
+  public static expectedTransactionControllerFindAll(
+    data: ExpectedTransactionControllerFindAllData
+  ): CancelablePromise<ExpectedTransactionControllerFindAllResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/bean/expected-transactions',
+      path: {
+        region: data.region
+      },
+      query: {
+        ruleId: data.ruleId,
         status: data.status,
         fromDate: data.fromDate,
         toDate: data.toDate
@@ -1500,162 +1958,621 @@ export class ExpectedTransactionsService {
   }
 
   /**
-   * List overdue expected transactions
-   * Returns all overdue expected transactions (PENDING past tolerance)
+   * List overdue expected transactions
+   * Returns all overdue expected transactions (PENDING past tolerance)
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @returns ExpectedTransactionListResponseDto Overdue transactions retrieved successfully
+   * @throws ApiError
+   */
+  public static expectedTransactionControllerFindOverdue(
+    data: ExpectedTransactionControllerFindOverdueData
+  ): CancelablePromise<ExpectedTransactionControllerFindOverdueResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/bean/expected-transactions/overdue',
+      path: {
+        region: data.region
+      }
+    });
+  }
+
+  /**
+   * Get expected transaction by ID
+   * Returns a specific expected transaction with rule details
+   * @param data The data for the request.
+   * @param data.id Expected transaction ID
+   * @param data.region Region code for tenant context
+   * @returns ExpectedTransactionResponseDto Expected transaction retrieved successfully
+   * @throws ApiError
+   */
+  public static expectedTransactionControllerFindOne(
+    data: ExpectedTransactionControllerFindOneData
+  ): CancelablePromise<ExpectedTransactionControllerFindOneResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/bean/expected-transactions/{id}',
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      errors: {
+        404: 'Expected transaction not found'
+      }
+    });
+  }
+
+  /**
+   * Skip expected transaction
+   * Marks an expected transaction as skipped (PENDING -> SKIPPED)
+   * @param data The data for the request.
+   * @param data.id Expected transaction ID
+   * @param data.region Region code for tenant context
+   * @returns ExpectedTransactionResponseDto Expected transaction skipped successfully
+   * @throws ApiError
+   */
+  public static expectedTransactionControllerSkip(
+    data: ExpectedTransactionControllerSkipData
+  ): CancelablePromise<ExpectedTransactionControllerSkipResponse> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/{region}/bean/expected-transactions/{id}/skip',
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      errors: {
+        400: 'Cannot skip - not in PENDING status',
+        404: 'Expected transaction not found'
+      }
+    });
+  }
+
+  /**
+   * Undo skip
+   * Reverses a skip operation (SKIPPED -> PENDING)
+   * @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
+   * @throws ApiError
+   */
+  public static expectedTransactionControllerUndoSkip(
+    data: ExpectedTransactionControllerUndoSkipData
+  ): CancelablePromise<ExpectedTransactionControllerUndoSkipResponse> {
+    return __request(OpenAPI, {
+      method: 'DELETE',
+      url: '/api/v1/{region}/bean/expected-transactions/{id}/skip',
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      errors: {
+        400: 'Cannot undo - not in SKIPPED status',
+        404: 'Expected transaction not found'
+      }
+    });
+  }
+
+  /**
+   * Confirm transaction match
+   * Manually matches an expected transaction with an actual transaction
+   * @param data The data for the request.
+   * @param data.id Expected transaction ID
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns unknown Match confirmed successfully
+   * @throws ApiError
+   */
+  public static expectedTransactionControllerConfirmMatch(
+    data: ExpectedTransactionControllerConfirmMatchData
+  ): CancelablePromise<ExpectedTransactionControllerConfirmMatchResponse> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/{region}/bean/expected-transactions/{id}/match',
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: 'Cannot match - not in PENDING status',
+        404: 'Expected or actual transaction not found',
+        409: 'Actual transaction already matched to another rule'
+      }
+    });
+  }
+
+  /**
+   * Unmatch transaction
+   * Removes the match between expected and actual transaction (COMPLETED -> PENDING)
+   * @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
+   * @throws ApiError
+   */
+  public static expectedTransactionControllerUnmatch(
+    data: ExpectedTransactionControllerUnmatchData
+  ): CancelablePromise<ExpectedTransactionControllerUnmatchResponse> {
+    return __request(OpenAPI, {
+      method: 'DELETE',
+      url: '/api/v1/{region}/bean/expected-transactions/{id}/match',
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      errors: {
+        400: 'Cannot unmatch - not in COMPLETED status',
+        404: 'Expected transaction not found'
+      }
+    });
+  }
+
+  /**
+   * Enter Now
+   * Creates an actual transaction for an expected transaction (YNAB-style Enter Now)
+   * @param data The data for the request.
+   * @param data.id Expected transaction ID
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns unknown Transaction created successfully
+   * @throws ApiError
+   */
+  public static expectedTransactionControllerEnterNow(
+    data: ExpectedTransactionControllerEnterNowData
+  ): CancelablePromise<ExpectedTransactionControllerEnterNowResponse> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/{region}/bean/expected-transactions/{id}/enter',
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: 'Cannot enter - not in PENDING status or missing accounts',
+        404: 'Expected transaction or accounts not found'
+      }
+    });
+  }
+}
+
+export class RecurringForecastService {
+  /**
+   * Get cash flow forecast
+   * Returns predicted outflows for the next N months based on active recurring rules
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @param data.months Number of months to forecast (1-12, default 3)
+   * @returns ForecastResponseDto Forecast retrieved successfully
+   * @throws ApiError
+   */
+  public static forecastControllerGetForecast(
+    data: ForecastControllerGetForecastData
+  ): CancelablePromise<ForecastControllerGetForecastResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/bean/recurring/forecast',
+      path: {
+        region: data.region
+      },
+      query: {
+        months: data.months
+      }
+    });
+  }
+}
+
+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)
+   *
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @param data.period Time period
+   * @param data.granularity Data granularity
+   * @returns PortfolioTrendsResponseDto Trends retrieved successfully
+   * @throws ApiError
+   */
+  public static reportingControllerGetPortfolioTrends(
+    data: ReportingControllerGetPortfolioTrendsData
+  ): CancelablePromise<ReportingControllerGetPortfolioTrendsResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/reporting/portfolio/trends',
+      path: {
+        region: data.region
+      },
+      query: {
+        period: data.period,
+        granularity: data.granularity
+      },
+      errors: {
+        401: 'User not authenticated'
+      }
+    });
+  }
+
+  /**
+   * 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.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 reportingControllerGetCashFlowTrends(
+    data: ReportingControllerGetCashFlowTrendsData
+  ): CancelablePromise<ReportingControllerGetCashFlowTrendsResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/reporting/cash-flow/trends',
+      path: {
+        region: data.region
+      },
+      query: {
+        period: data.period,
+        granularity: data.granularity
+      },
+      errors: {
+        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
+   *
+   * @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
+   * @throws ApiError
+   */
+  public static reportingControllerGenerateSnapshot(
+    data: ReportingControllerGenerateSnapshotData
+  ): CancelablePromise<ReportingControllerGenerateSnapshotResponse> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/{region}/reporting/snapshots/generate',
+      path: {
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: 'Invalid date format',
+        401: 'User not authenticated'
+      }
+    });
+  }
+
+  /**
+   * 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 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 unknown 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.region Region code (cn, us, de)
-   * @returns ExpectedTransactionListResponseDto Overdue transactions retrieved successfully
+   * @param data.requestBody
+   * @returns SignupResponseDto User created successfully
    * @throws ApiError
    */
-  public static expectedTransactionControllerFindOverdue(
-    data: ExpectedTransactionControllerFindOverdueData
-  ): CancelablePromise<ExpectedTransactionControllerFindOverdueResponse> {
+  public static userControllerSignupUser(
+    data: UserControllerSignupUserData
+  ): CancelablePromise<UserControllerSignupUserResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/{region}/bean/expected-transactions/overdue',
-      path: {
-        region: data.region
+      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'
       }
     });
   }
 
   /**
-   * Get expected transaction by ID
-   * Returns a specific expected transaction with rule details
+   * Delete user by ID (admin only)
    * @param data The data for the request.
-   * @param data.id Expected transaction ID
-   * @param data.region Region code (cn, us, de)
-   * @returns ExpectedTransactionResponseDto Expected transaction retrieved successfully
+   * @param data.id User ID to delete
+   * @returns void User deleted successfully
    * @throws ApiError
    */
-  public static expectedTransactionControllerFindOne(
-    data: ExpectedTransactionControllerFindOneData
-  ): CancelablePromise<ExpectedTransactionControllerFindOneResponse> {
+  public static userControllerDeleteUser(
+    data: UserControllerDeleteUserData
+  ): CancelablePromise<UserControllerDeleteUserResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/{region}/bean/expected-transactions/{id}',
+      method: 'DELETE',
+      url: '/api/v1/users/{id}',
       path: {
-        id: data.id,
-        region: data.region
+        id: data.id
       },
       errors: {
-        404: 'Expected transaction not found'
+        403: 'Cannot delete own account or insufficient permissions'
       }
     });
   }
 
   /**
+   * Get user info by user ID
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.id User ID
+   * @returns unknown User info retrieved successfully
    * @throws ApiError
    */
-  public static expectedTransactionController(
-    data: ExpectedTransactionControllerData
-  ): CancelablePromise<ExpectedTransactionControllerResponse> {
+  public static userControllerGetUserInfo(
+    data: UserControllerGetUserInfoData
+  ): CancelablePromise<UserControllerGetUserInfoResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/{region}/bean/expected-transactions/{id}/skip',
+      method: 'GET',
+      url: '/api/v1/users/{id}/info',
       path: {
-        region: data.region
+        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.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.requestBody
+   * @returns unknown Settings updated successfully
    * @throws ApiError
    */
-  public static expectedTransactionController1(
-    data: ExpectedTransactionController1Data
-  ): CancelablePromise<ExpectedTransactionController1Response> {
+  public static userControllerUpdateUserSetting(
+    data: UserControllerUpdateUserSettingData
+  ): CancelablePromise<UserControllerUpdateUserSettingResponse> {
     return __request(OpenAPI, {
-      method: 'DELETE',
-      url: '/api/v1/{region}/bean/expected-transactions/{id}/skip',
-      path: {
-        region: data.region
+      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.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.pageNo Page number
+   * @param data.pageSize Page size
+   * @returns unknown Settings list retrieved successfully
    * @throws ApiError
    */
-  public static expectedTransactionController2(
-    data: ExpectedTransactionController2Data
-  ): CancelablePromise<ExpectedTransactionController2Response> {
+  public static userControllerGetAllUserSettingsByPage(
+    data: UserControllerGetAllUserSettingsByPageData
+  ): CancelablePromise<UserControllerGetAllUserSettingsByPageResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/{region}/bean/expected-transactions/{id}/match',
-      path: {
-        region: data.region
+      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.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.key Property key
+   * @returns unknown Property retrieved successfully
    * @throws ApiError
    */
-  public static expectedTransactionController3(
-    data: ExpectedTransactionController3Data
-  ): CancelablePromise<ExpectedTransactionController3Response> {
+  public static propertyControllerGetByKey(
+    data: PropertyControllerGetByKeyData
+  ): CancelablePromise<PropertyControllerGetByKeyResponse> {
     return __request(OpenAPI, {
-      method: 'DELETE',
-      url: '/api/v1/{region}/bean/expected-transactions/{id}/match',
+      method: 'GET',
+      url: '/api/v1/admin/properties/{key}',
       path: {
-        region: data.region
+        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.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.key Property key
+   * @param data.requestBody
+   * @returns unknown Property updated successfully
    * @throws ApiError
    */
-  public static expectedTransactionController4(
-    data: ExpectedTransactionController4Data
-  ): CancelablePromise<ExpectedTransactionController4Response> {
+  public static propertyControllerUpdate(
+    data: PropertyControllerUpdateData
+  ): CancelablePromise<PropertyControllerUpdateResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/{region}/bean/expected-transactions/{id}/enter',
+      method: 'PUT',
+      url: '/api/v1/admin/properties/{key}',
       path: {
-        region: data.region
+        key: data.key
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        401: 'Unauthorized',
+        403: 'Forbidden - insufficient permissions'
       }
     });
   }
-}
 
-export class RecurringForecastService {
   /**
-   * Get cash flow forecast
-   * Returns predicted outflows for the next N months based on active recurring rules
+   * Delete a system property
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @param data.months Number of months to forecast (1-12, default 3)
-   * @returns ForecastResponseDto Forecast retrieved successfully
+   * @param data.key Property key
+   * @returns void Property deleted successfully
    * @throws ApiError
    */
-  public static forecastControllerGetForecast(
-    data: ForecastControllerGetForecastData
-  ): CancelablePromise<ForecastControllerGetForecastResponse> {
+  public static propertyControllerDelete(
+    data: PropertyControllerDeleteData
+  ): CancelablePromise<PropertyControllerDeleteResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/{region}/bean/recurring/forecast',
+      method: 'DELETE',
+      url: '/api/v1/admin/properties/{key}',
       path: {
-        region: data.region
+        key: data.key
       },
-      query: {
-        months: data.months
+      errors: {
+        401: 'Unauthorized',
+        403: 'Forbidden - insufficient permissions',
+        404: 'Property not found'
       }
     });
   }
@@ -1663,19 +2580,29 @@ export class RecurringForecastService {
 
 export class BeanTransactionRulesService {
   /**
+   * Create a new transaction rule (or upsert if upsertByPayee=true)
+   * Creates a new rule. If upsertByPayee=true, updates existing rule matching payeeKeywords[0] instead of creating duplicate.
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns TransactionRuleResponseDto Rule updated successfully (upsert mode)
    * @throws ApiError
    */
-  public static transactionRuleController(
-    data: TransactionRuleControllerData
-  ): CancelablePromise<TransactionRuleControllerResponse> {
+  public static transactionRuleControllerCreate(
+    data: TransactionRuleControllerCreateData
+  ): CancelablePromise<TransactionRuleControllerCreateResponse> {
     return __request(OpenAPI, {
       method: 'POST',
       url: '/api/v1/{region}/bean/transaction-rules',
       path: {
         region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: 'Validation failed',
+        401: 'Unauthorized',
+        409: 'Resource conflict - another process is updating this rule'
       }
     });
   }
@@ -1683,7 +2610,7 @@ export class BeanTransactionRulesService {
   /**
    * Get all transaction rules for user
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
+   * @param data.region Region code for tenant context
    * @param data.limit Max results per page (default: 20, max: 100)
    * @param data.offset Pagination offset (default: 0)
    * @param data.enabled Filter by enabled status
@@ -1717,7 +2644,7 @@ export class BeanTransactionRulesService {
   /**
    * Validate transaction rule configuration
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
+   * @param data.region Region code for tenant context
    * @param data.requestBody
    * @returns ValidateRuleResponseDto Validation result
    * @throws ApiError
@@ -1734,25 +2661,34 @@ export class BeanTransactionRulesService {
       body: data.requestBody,
       mediaType: 'application/json',
       errors: {
+        400: 'Validation failed',
         401: 'Unauthorized'
       }
     });
   }
 
   /**
+   * Bulk create transaction rules
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns BulkCreateRulesResponseDto Bulk create completed
    * @throws ApiError
    */
-  public static transactionRuleController1(
-    data: TransactionRuleController1Data
-  ): CancelablePromise<TransactionRuleController1Response> {
+  public static transactionRuleControllerBulkCreate(
+    data: TransactionRuleControllerBulkCreateData
+  ): CancelablePromise<TransactionRuleControllerBulkCreateResponse> {
     return __request(OpenAPI, {
       method: 'POST',
       url: '/api/v1/{region}/bean/transaction-rules/bulk',
       path: {
         region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: 'Invalid bulk create data',
+        401: 'Unauthorized'
       }
     });
   }
@@ -1761,7 +2697,7 @@ export class BeanTransactionRulesService {
    * Export transaction rules
    * @param data The data for the request.
    * @param data.format Export format (currently only JSON supported)
-   * @param data.region Region code (cn, us, de)
+   * @param data.region Region code for tenant context
    * @returns ExportRulesResponseDto Exported rules
    * @throws ApiError
    */
@@ -1786,7 +2722,7 @@ export class BeanTransactionRulesService {
    * Get transaction rule statistics
    * @param data The data for the request.
    * @param data.period Statistics time period
-   * @param data.region Region code (cn, us, de)
+   * @param data.region Region code for tenant context
    * @returns RuleStatisticsResponseDto Rule statistics
    * @throws ApiError
    */
@@ -1810,7 +2746,7 @@ export class BeanTransactionRulesService {
    * Get transaction rule detail
    * @param data The data for the request.
    * @param data.ruleId Rule ID
-   * @param data.region Region code (cn, us, de)
+   * @param data.region Region code for tenant context
    * @returns TransactionRuleResponseDto Rule details
    * @throws ApiError
    */
@@ -1833,37 +2769,59 @@ export class BeanTransactionRulesService {
   }
 
   /**
+   * Update a transaction rule
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.ruleId Rule ID to update
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns TransactionRuleResponseDto Rule updated successfully
    * @throws ApiError
    */
-  public static transactionRuleController2(
-    data: TransactionRuleController2Data
-  ): CancelablePromise<TransactionRuleController2Response> {
+  public static transactionRuleControllerUpdate(
+    data: TransactionRuleControllerUpdateData
+  ): CancelablePromise<TransactionRuleControllerUpdateResponse> {
     return __request(OpenAPI, {
       method: 'PUT',
       url: '/api/v1/{region}/bean/transaction-rules/{ruleId}',
       path: {
+        ruleId: data.ruleId,
         region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: 'Validation failed',
+        401: 'Unauthorized',
+        403: 'Forbidden - not owner of rule',
+        404: 'Rule not found',
+        409: 'Resource conflict - rule is being modified by another process'
       }
     });
   }
 
   /**
+   * Delete a transaction rule
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns void
+   * @param data.ruleId Rule ID to delete
+   * @param data.region Region code for tenant context
+   * @returns void Rule deleted successfully
    * @throws ApiError
    */
-  public static transactionRuleController3(
-    data: TransactionRuleController3Data
-  ): CancelablePromise<TransactionRuleController3Response> {
+  public static transactionRuleControllerDelete(
+    data: TransactionRuleControllerDeleteData
+  ): CancelablePromise<TransactionRuleControllerDeleteResponse> {
     return __request(OpenAPI, {
       method: 'DELETE',
       url: '/api/v1/{region}/bean/transaction-rules/{ruleId}',
       path: {
+        ruleId: data.ruleId,
         region: data.region
+      },
+      errors: {
+        401: 'Unauthorized',
+        403: 'Forbidden - not owner of rule',
+        404: 'Rule not found',
+        409: 'Resource conflict - rule is being modified by another process'
       }
     });
   }
@@ -1872,7 +2830,7 @@ export class BeanTransactionRulesService {
    * Test rule matching
    * @param data The data for the request.
    * @param data.ruleId Rule ID to test
-   * @param data.region Region code (cn, us, de)
+   * @param data.region Region code for tenant context
    * @param data.requestBody
    * @returns TestRuleResponseDto Test result
    * @throws ApiError
@@ -1898,283 +2856,325 @@ export class BeanTransactionRulesService {
   }
 }
 
-export class UsersService {
+export class LifeEventsService {
   /**
-   * Delete own user account
+   * 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.region Region code (cn, us, de)
+   * @param data.region Region code for tenant context (decorative for life events)
    * @param data.requestBody
-   * @returns void User deleted successfully
+   * @returns EventResponseDto Life event created successfully
    * @throws ApiError
    */
-  public static userControllerDeleteOwnUser(
-    data: UserControllerDeleteOwnUserData
-  ): CancelablePromise<UserControllerDeleteOwnUserResponse> {
+  public static eventControllerCreate(
+    data: EventControllerCreateData
+  ): CancelablePromise<EventControllerCreateResponse> {
     return __request(OpenAPI, {
-      method: 'DELETE',
-      url: '/api/v1/users',
+      method: 'POST',
+      url: '/api/v1/{region}/bean/events',
       path: {
         region: data.region
       },
       body: data.requestBody,
       mediaType: 'application/json',
       errors: {
-        403: 'Invalid access token'
+        409: 'Life event already exists for this (userId, type, date) combination'
+      }
+    });
+  }
+
+  /**
+   * 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.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 eventControllerFindAll(
+    data: EventControllerFindAllData
+  ): CancelablePromise<EventControllerFindAllResponse> {
+    return __request(OpenAPI, {
+      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
       }
     });
   }
 
   /**
-   * Get current authenticated user
+   * 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.acceptLanguage
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown User retrieved 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 userControllerGetUser(
-    data: UserControllerGetUserData
-  ): CancelablePromise<UserControllerGetUserResponse> {
+  public static eventControllerFindOne(
+    data: EventControllerFindOneData
+  ): CancelablePromise<EventControllerFindOneResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/users',
+      url: '/api/v1/{region}/bean/events/{id}',
       path: {
+        id: data.id,
         region: data.region
       },
-      headers: {
-        'accept-language': data.acceptLanguage
+      errors: {
+        404: 'Life event not found'
       }
     });
   }
 
   /**
-   * Sign up new user
-   * Create a new account with auto-generated access token. Protected by Cloudflare Turnstile to prevent automated signup (when enabled).
+   * 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.region Region code (cn, us, de)
+   * @param data.id Life event ID
+   * @param data.region Region code for tenant context (decorative for life events)
    * @param data.requestBody
-   * @returns unknown User created successfully
+   * @returns EventResponseDto Life event updated successfully
    * @throws ApiError
    */
-  public static userControllerSignupUser(
-    data: UserControllerSignupUserData
-  ): CancelablePromise<UserControllerSignupUserResponse> {
+  public static eventControllerUpdate(
+    data: EventControllerUpdateData
+  ): CancelablePromise<EventControllerUpdateResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/users',
+      method: 'PUT',
+      url: '/api/v1/{region}/bean/events/{id}',
       path: {
+        id: data.id,
         region: data.region
       },
       body: data.requestBody,
       mediaType: 'application/json',
       errors: {
-        400: 'Invalid Turnstile token (when Turnstile is enabled)',
-        403: 'User signup is disabled'
+        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)'
       }
     });
   }
 
   /**
-   * Delete user by ID (admin only)
+   * Delete a life event
+   * Deletes a life event entry (hard delete). Returns 204.
    * @param data The data for the request.
-   * @param data.id User ID to delete
-   * @param data.region Region code (cn, us, de)
-   * @returns void User deleted 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 userControllerDeleteUser(
-    data: UserControllerDeleteUserData
-  ): CancelablePromise<UserControllerDeleteUserResponse> {
+  public static eventControllerDelete(
+    data: EventControllerDeleteData
+  ): CancelablePromise<EventControllerDeleteResponse> {
     return __request(OpenAPI, {
       method: 'DELETE',
-      url: '/api/v1/users/{id}',
+      url: '/api/v1/{region}/bean/events/{id}',
       path: {
         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
+   * 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.id User ID
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown User info 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 userControllerGetUserInfo(
-    data: UserControllerGetUserInfoData
-  ): CancelablePromise<UserControllerGetUserInfoResponse> {
+  public static eventControllerGetSlice(
+    data: EventControllerGetSliceData
+  ): CancelablePromise<EventControllerGetSliceResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/users/{id}/info',
+      url: '/api/v1/{region}/bean/events/{id}/slice',
       path: {
         id: data.id,
         region: data.region
       },
+      query: {
+        accountPattern: data.accountPattern,
+        granularity: data.granularity
+      },
       errors: {
-        403: 'Cannot access other user info without admin permission'
+        400: 'accountPattern query param is empty',
+        404: 'Life event not found'
       }
     });
   }
+}
 
+export class OnboardingService {
   /**
-   * Update user settings
+   * Bootstrap core accounts + register asset accounts with opening balances (ADR-0113)
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
+   * @param data.region Region code for tenant context
    * @param data.requestBody
-   * @returns unknown Settings updated successfully
+   * @returns unknown Onboarding bootstrap result.
    * @throws ApiError
    */
-  public static userControllerUpdateUserSetting(
-    data: UserControllerUpdateUserSettingData
-  ): CancelablePromise<UserControllerUpdateUserSettingResponse> {
+  public static onboardingControllerBootstrap(
+    data: OnboardingControllerBootstrapData
+  ): CancelablePromise<OnboardingControllerBootstrapResponse> {
     return __request(OpenAPI, {
-      method: 'PUT',
-      url: '/api/v1/users/setting',
+      method: 'POST',
+      url: '/api/v1/{region}/bean/onboarding',
       path: {
         region: data.region
       },
       body: data.requestBody,
       mediaType: 'application/json',
       errors: {
-        403: 'Insufficient permissions'
+        422: 'Invalid region/account path/duplicate paths.'
       }
     });
   }
+}
 
+export class BalanceReconciliationService {
   /**
-   * Get all user settings paginated (admin only)
+   * 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.pageNo Page number
-   * @param data.pageSize Page size
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown Settings list retrieved successfully
+   * @param data.region Region code for tenant context (decorative for reconciliation)
+   * @param data.requestBody
+   * @returns ReconciliationComputeResultDto Reconciliation preview
    * @throws ApiError
    */
-  public static userControllerGetAllUserSettingsByPage(
-    data: UserControllerGetAllUserSettingsByPageData
-  ): CancelablePromise<UserControllerGetAllUserSettingsByPageResponse> {
+  public static reconciliationControllerCompute(
+    data: ReconciliationControllerComputeData
+  ): CancelablePromise<ReconciliationControllerComputeResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/users/settings-by-page',
+      method: 'POST',
+      url: '/api/v1/{region}/bean/reconciliations',
       path: {
         region: data.region
       },
-      query: {
-        pageNo: data.pageNo,
-        pageSize: data.pageSize
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        404: 'Account not found'
       }
     });
   }
 
   /**
-   * Get asset and liability summary for current user
+   * 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.region Region code (cn, us, de)
-   * @returns unknown Summary 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 userControllerGetAssetLiabilitySummary(
-    data: UserControllerGetAssetLiabilitySummaryData
-  ): CancelablePromise<UserControllerGetAssetLiabilitySummaryResponse> {
+  public static reconciliationControllerAssert(
+    data: ReconciliationControllerAssertData
+  ): CancelablePromise<ReconciliationControllerAssertResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/users/asset-liability-summary',
+      method: 'POST',
+      url: '/api/v1/{region}/bean/reconciliations/assert',
       path: {
         region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        404: 'Account not found'
       }
     });
   }
-}
 
-export class PropertiesService {
   /**
-   * Get all system properties
+   * 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.region Region code (cn, us, de)
-   * @returns unknown Properties retrieved successfully
+   * @param data.region Region code for tenant context (decorative for reconciliation)
+   * @param data.requestBody
+   * @returns PadResultDto Pad adjusting entry generated
    * @throws ApiError
    */
-  public static propertyControllerGetAll(
-    data: PropertyControllerGetAllData
-  ): CancelablePromise<PropertyControllerGetAllResponse> {
+  public static reconciliationControllerPad(
+    data: ReconciliationControllerPadData
+  ): CancelablePromise<ReconciliationControllerPadResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/admin/properties',
+      method: 'POST',
+      url: '/api/v1/{region}/bean/reconciliations/pad',
       path: {
         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'
       }
     });
   }
 
   /**
-   * Get property by key
+   * 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
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown Property retrieved 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 propertyControllerGetByKey(
-    data: PropertyControllerGetByKeyData
-  ): CancelablePromise<PropertyControllerGetByKeyResponse> {
+  public static reconciliationControllerHistory(
+    data: ReconciliationControllerHistoryData
+  ): CancelablePromise<ReconciliationControllerHistoryResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/admin/properties/{key}',
+      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'
       }
     });
   }
+}
 
+export class BeanExportService {
   /**
-   * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
+   * 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
    * @throws ApiError
    */
-  public static propertyController(
-    data: PropertyControllerData
-  ): CancelablePromise<PropertyControllerResponse> {
-    return __request(OpenAPI, {
-      method: 'PUT',
-      url: '/api/v1/admin/properties/{key}',
-      path: {
-        region: data.region
-      }
-    });
-  }
-
-  /**
-   * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns void
-   * @throws ApiError
-   */
-  public static propertyController1(
-    data: PropertyController1Data
-  ): CancelablePromise<PropertyController1Response> {
+  public static exportControllerExportBeancount(): CancelablePromise<ExportControllerExportBeancountResponse> {
     return __request(OpenAPI, {
-      method: 'DELETE',
-      url: '/api/v1/admin/properties/{key}',
-      path: {
-        region: data.region
-      }
+      method: 'GET',
+      url: '/api/v1/{region}/bean/export/beancount'
     });
   }
 }
@@ -2184,7 +3184,7 @@ export class BeanImportService {
    * Import a bill file
    * Upload and process a bill file (CSV, PDF, OFX, etc.). The system automatically identifies the file type, extracts transactions, validates them, and stores only validated transactions to the database. Maximum file size: 50MB. Only 1 import per user at a time (concurrent imports rejected with 429).
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
+   * @param data.region Region code for tenant context
    * @param data.formData Bill file to import
    * @returns ImportResultDto File imported successfully
    * @throws ApiError
@@ -2213,7 +3213,7 @@ export class BeanImportService {
    * Identify file type
    * Upload a file to check if it can be processed by any registered importer. Does not perform actual import - useful for pre-validation. Uses user-specific importer configuration.
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
+   * @param data.region Region code for tenant context
    * @param data.formData File to identify
    * @returns IdentifyResultDto File identification result
    * @throws ApiError
@@ -2235,12 +3235,38 @@ 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
+   * @param data.formData Beancount file to import
+   * @returns unknown Beancount file imported successfully
+   * @throws ApiError
+   */
+  public static fileImportControllerImportBeancount(
+    data: FileImportControllerImportBeancountData
+  ): CancelablePromise<FileImportControllerImportBeancountResponse> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      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'
+      }
+    });
+  }
+
   /**
    * Get importer configuration
    * Returns the current configuration for the specified importer. Creates default configuration if none exists.
    * @param data The data for the request.
-   * @param data.importerId Importer identifier. Supported importers: alipay, alipay-web, wechat, boc, boc-credit, ccb, cmb, cmbc, cmbc-credit, icbc, icbc-credit, hsbc-hk
-   * @param data.region Region code (cn, us, de)
+   * @param data.importerId Importer identifier. Supported importers: alipay, alipay-web, wechat, boc, boc-credit, ccb, cmb, cmbc, cmbc-credit, icbc, icbc-credit, hsbc-hk-credit, hsbc-hk-debit
+   * @param data.region Region code for tenant context
    * @returns ImporterConfigDto Configuration retrieved successfully
    * @throws ApiError
    */
@@ -2262,37 +3288,55 @@ export class BeanImportService {
   }
 
   /**
+   * Update importer configuration
+   * Updates the configuration for the specified importer. Partial updates are supported.
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.importerId Importer identifier. Supported importers: alipay, alipay-web, wechat, boc, boc-credit, ccb, cmb, cmbc, cmbc-credit, icbc, icbc-credit, hsbc-hk-credit, hsbc-hk-debit
+   * @param data.region Region code for tenant context
+   * @param data.requestBody Partial configuration update. Only provided fields will be updated.
+   * @returns ImporterConfigDto Configuration updated successfully
    * @throws ApiError
    */
-  public static importerConfigController(
-    data: ImporterConfigControllerData
-  ): CancelablePromise<ImporterConfigControllerResponse> {
+  public static importerConfigControllerUpdateConfig(
+    data: ImporterConfigControllerUpdateConfigData
+  ): CancelablePromise<ImporterConfigControllerUpdateConfigResponse> {
     return __request(OpenAPI, {
       method: 'PUT',
       url: '/api/v1/{region}/bean/import/config/{importerId}',
       path: {
+        importerId: data.importerId,
         region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: 'Invalid input - Validation failed',
+        404: 'Configuration not found'
       }
     });
   }
 
   /**
+   * Reset configuration to default
+   * Resets the configuration for the specified importer to default values. This operation overwrites all existing configuration.
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.importerId Importer identifier. Supported importers: alipay, alipay-web, wechat, boc, boc-credit, ccb, cmb, cmbc, cmbc-credit, icbc, icbc-credit, hsbc-hk-credit, hsbc-hk-debit
+   * @param data.region Region code for tenant context
+   * @returns ImporterConfigDto Configuration reset successfully
    * @throws ApiError
    */
-  public static importerConfigController1(
-    data: ImporterConfigController1Data
-  ): CancelablePromise<ImporterConfigController1Response> {
+  public static importerConfigControllerResetConfig(
+    data: ImporterConfigControllerResetConfigData
+  ): CancelablePromise<ImporterConfigControllerResetConfigResponse> {
     return __request(OpenAPI, {
       method: 'POST',
       url: '/api/v1/{region}/bean/import/config/{importerId}/reset',
       path: {
+        importerId: data.importerId,
         region: data.region
+      },
+      errors: {
+        400: 'Invalid input - Unsupported importer'
       }
     });
   }
@@ -2323,76 +3367,171 @@ export class ProviderSyncService {
    * 6. Persist validated transactions
    *
    * @param data The data for the request.
-   * @param data.providerName Provider name
-   * @param data.region Region code
+   * @param data.providerName Provider name
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns ProviderSyncResponseDto Sync completed successfully
+   * @throws ApiError
+   */
+  public static providerSyncControllerSync(
+    data: ProviderSyncControllerSyncData
+  ): CancelablePromise<ProviderSyncControllerSyncResponse> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/{region}/bean/import/provider/{providerName}/sync',
+      path: {
+        providerName: data.providerName,
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: 'Invalid request data',
+        401: 'Missing or invalid authentication',
+        404: 'Provider not supported'
+      }
+    });
+  }
+
+  /**
+   * Get supported providers
+   * Returns a list of all providers supported by the sync endpoint.
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @returns SupportedProvidersResponseDto List of supported providers
+   * @throws ApiError
+   */
+  public static providerSyncControllerGetSupportedProviders(
+    data: ProviderSyncControllerGetSupportedProvidersData
+  ): CancelablePromise<ProviderSyncControllerGetSupportedProvidersResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/bean/import/provider/supported',
+      path: {
+        region: data.region
+      },
+      errors: {
+        401: 'Missing or invalid authentication'
+      }
+    });
+  }
+
+  /**
+   * Check if provider is supported
+   * Returns whether a specific provider is supported.
+   * @param data The data for the request.
+   * @param data.providerName Provider name to check
+   * @param data.region Region code for tenant context
+   * @returns unknown Provider support status
+   * @throws ApiError
+   */
+  public static providerSyncControllerIsProviderSupported(
+    data: ProviderSyncControllerIsProviderSupportedData
+  ): CancelablePromise<ProviderSyncControllerIsProviderSupportedResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/bean/import/provider/{providerName}/supported',
+      path: {
+        providerName: data.providerName,
+        region: data.region
+      },
+      errors: {
+        401: 'Missing or invalid authentication'
+      }
+    });
+  }
+}
+
+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 ProviderSyncResponseDto Sync completed successfully
+   * @returns ExternalAccountLinkResponseDto Link created.
    * @throws ApiError
    */
-  public static providerSyncControllerSync(
-    data: ProviderSyncControllerSyncData
-  ): CancelablePromise<ProviderSyncControllerSyncResponse> {
+  public static externalAccountLinkControllerCreate(
+    data: ExternalAccountLinkControllerCreateData
+  ): CancelablePromise<ExternalAccountLinkControllerCreateResponse> {
     return __request(OpenAPI, {
       method: 'POST',
-      url: '/api/v1/{region}/bean/import/provider/{providerName}/sync',
+      url: '/api/v1/{region}/bean/external-account-links',
       path: {
-        providerName: data.providerName,
         region: data.region
       },
       body: data.requestBody,
       mediaType: 'application/json',
       errors: {
-        400: 'Invalid request data',
-        401: 'Missing or invalid authentication',
-        404: 'Provider not supported'
+        422: 'beanAccountId not owned, or an active link already exists.'
       }
     });
   }
 
   /**
-   * Get supported providers
-   * Returns a list of all providers supported by the sync endpoint.
+   * List the user's active external account links
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns SupportedProvidersResponseDto List of supported providers
+   * @param data.provider
+   * @param data.region Region code for tenant context
+   * @returns ExternalAccountLinkListResponseDto Links retrieved.
    * @throws ApiError
    */
-  public static providerSyncControllerGetSupportedProviders(
-    data: ProviderSyncControllerGetSupportedProvidersData
-  ): CancelablePromise<ProviderSyncControllerGetSupportedProvidersResponse> {
+  public static externalAccountLinkControllerFindAll(
+    data: ExternalAccountLinkControllerFindAllData
+  ): CancelablePromise<ExternalAccountLinkControllerFindAllResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/{region}/bean/import/provider/supported',
+      url: '/api/v1/{region}/bean/external-account-links',
       path: {
         region: data.region
       },
-      errors: {
-        401: 'Missing or invalid authentication'
+      query: {
+        provider: data.provider
       }
     });
   }
 
   /**
-   * Check if provider is supported
-   * Returns whether a specific provider is supported.
+   * Get a single external account link
    * @param data The data for the request.
-   * @param data.providerName Provider name to check
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown Provider support status
+   * @param data.id
+   * @param data.region Region code for tenant context
+   * @returns ExternalAccountLinkResponseDto Link retrieved.
    * @throws ApiError
    */
-  public static providerSyncControllerIsProviderSupported(
-    data: ProviderSyncControllerIsProviderSupportedData
-  ): CancelablePromise<ProviderSyncControllerIsProviderSupportedResponse> {
+  public static externalAccountLinkControllerFindOne(
+    data: ExternalAccountLinkControllerFindOneData
+  ): CancelablePromise<ExternalAccountLinkControllerFindOneResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/{region}/bean/import/provider/{providerName}/supported',
+      url: '/api/v1/{region}/bean/external-account-links/{id}',
       path: {
-        providerName: data.providerName,
+        id: data.id,
         region: data.region
       },
       errors: {
-        401: 'Missing or invalid authentication'
+        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
       }
     });
   }
@@ -2402,7 +3541,7 @@ export class ImportTelemetryService {
   /**
    * Receive anonymous parser failure telemetry
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
+   * @param data.region Region code for tenant context
    * @param data.requestBody
    * @returns unknown Telemetry report received
    * @throws ApiError
@@ -2423,6 +3562,54 @@ export class ImportTelemetryService {
       }
     });
   }
+
+  /**
+   * Receive anonymous zero-hit coverage miss report
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns unknown Coverage miss report received
+   * @throws ApiError
+   */
+  public static telemetryControllerReportCoverageMiss(
+    data: TelemetryControllerReportCoverageMissData
+  ): CancelablePromise<TelemetryControllerReportCoverageMissResponse> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/{region}/bean/import/parser-coverage-miss',
+      path: {
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        401: 'Unauthorized'
+      }
+    });
+  }
+
+  /**
+   * Coverage metrics (uncovered format aggregation)
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @param data.topN Top-N uncovered formats (default 10)
+   * @returns unknown Coverage metrics
+   * @throws ApiError
+   */
+  public static telemetryControllerGetCoverageMetrics(
+    data: TelemetryControllerGetCoverageMetricsData
+  ): CancelablePromise<TelemetryControllerGetCoverageMetricsResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/bean/import/parser-coverage-metrics',
+      path: {
+        region: data.region
+      },
+      query: {
+        topN: data.topN
+      }
+    });
+  }
 }
 
 export class BeanNlpService {
@@ -2430,7 +3617,7 @@ 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 (cn, us, de)
+   * @param data.region Region code for tenant context
    * @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
@@ -2457,7 +3644,7 @@ export class BeanNlpService {
    * Clear dialogue session
    * Clear the current NLP dialogue session. Use this to cancel an ongoing multi-turn dialogue.
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
+   * @param data.region Region code for tenant context
    * @param data.sessionId Specific session ID to clear (defaults to user session)
    * @returns void Session cleared successfully
    * @throws ApiError
@@ -2484,7 +3671,7 @@ export class BeanNlpService {
    * Get current session state
    * Get the current NLP dialogue session state. Useful for debugging and displaying session context in UI.
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
+   * @param data.region Region code for tenant context
    * @param data.sessionId Specific session ID to get (defaults to user session)
    * @returns unknown Current session state (or null if no active session)
    * @throws ApiError
@@ -2511,37 +3698,33 @@ export class BeanNlpService {
 export class BeanPlatformsService {
   /**
    * Get all platforms with statistics
-   * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
    * @returns unknown List of platforms with binding and account counts
    * @throws ApiError
    */
-  public static platformControllerFindAll(
-    data: PlatformControllerFindAllData
-  ): CancelablePromise<PlatformControllerFindAllResponse> {
+  public static platformControllerFindAll(): CancelablePromise<PlatformControllerFindAllResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/bean/platforms',
-      path: {
-        region: data.region
-      }
+      url: '/api/v1/bean/platforms'
     });
   }
 
   /**
+   * Create a new platform
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
+   * @param data.requestBody
+   * @returns unknown Platform created successfully
    * @throws ApiError
    */
-  public static platformController(
-    data: PlatformControllerData
-  ): CancelablePromise<PlatformControllerResponse> {
+  public static platformControllerCreate(
+    data: PlatformControllerCreateData
+  ): CancelablePromise<PlatformControllerCreateResponse> {
     return __request(OpenAPI, {
       method: 'POST',
       url: '/api/v1/bean/platforms',
-      path: {
-        region: data.region
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        409: 'Platform already exists'
       }
     });
   }
@@ -2549,191 +3732,86 @@ export class BeanPlatformsService {
   /**
    * Get platform list for current user
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown List of platforms with user binding status
+   * @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 platformControllerGetPlatformList(
-    data: PlatformControllerGetPlatformListData
+    data: PlatformControllerGetPlatformListData = {}
   ): CancelablePromise<PlatformControllerGetPlatformListResponse> {
     return __request(OpenAPI, {
       method: 'GET',
       url: '/api/v1/bean/platforms/list',
-      path: {
-        region: data.region
-      }
-    });
-  }
-
-  /**
-   * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
-   * @throws ApiError
-   */
-  public static platformController1(
-    data: PlatformController1Data
-  ): CancelablePromise<PlatformController1Response> {
-    return __request(OpenAPI, {
-      method: 'PUT',
-      url: '/api/v1/bean/platforms/{id}',
-      path: {
-        region: data.region
-      }
-    });
-  }
-
-  /**
-   * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns void
-   * @throws ApiError
-   */
-  public static platformController2(
-    data: PlatformController2Data
-  ): CancelablePromise<PlatformController2Response> {
-    return __request(OpenAPI, {
-      method: 'DELETE',
-      url: '/api/v1/bean/platforms/{id}',
-      path: {
+      query: {
         region: data.region
       }
     });
   }
-}
 
-export class SymbolsService {
   /**
-   * Search for symbols
-   * Search symbols by query with optional filters for asset class, area, and indices
+   * Match platforms by name or alias
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @param data.includeIndices Include index symbols in results
-   * @param data.assetSubClass Asset sub-class filter
-   * @param data.assetClass Asset class filter
-   * @param data.area Geographic area filter (e.g., CN, US)
-   * @param data.query Search query string
-   * @returns unknown Symbols found 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 symbolControllerLookupSymbol(
-    data: SymbolControllerLookupSymbolData
-  ): CancelablePromise<SymbolControllerLookupSymbolResponse> {
+  public static platformControllerMatchPlatforms(
+    data: PlatformControllerMatchPlatformsData
+  ): CancelablePromise<PlatformControllerMatchPlatformsResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/market/symbols/lookup',
-      path: {
-        region: data.region
-      },
+      url: '/api/v1/bean/platforms/match',
       query: {
-        includeIndices: data.includeIndices,
-        assetSubClass: data.assetSubClass,
-        assetClass: data.assetClass,
-        area: data.area,
-        query: data.query
-      },
-      errors: {
-        400: 'Invalid query parameters'
+        q: data.q,
+        region: data.region
       }
     });
   }
 
   /**
-   * Get symbol data
-   * Retrieve detailed symbol information including optional historical data
+   * Update a platform
    * @param data The data for the request.
-   * @param data.dataSource Data source provider
-   * @param data.symbol Symbol identifier (e.g., ticker code)
-   * @param data.region Region code (cn, us, de)
-   * @param data.includeHistoricalData Include historical price data (0 or 1)
-   * @returns unknown Symbol data retrieved successfully
+   * @param data.id Platform ID
+   * @param data.requestBody
+   * @returns unknown Platform updated successfully
    * @throws ApiError
    */
-  public static symbolControllerGetSymbolData(
-    data: SymbolControllerGetSymbolDataData
-  ): CancelablePromise<SymbolControllerGetSymbolDataResponse> {
+  public static platformControllerUpdate(
+    data: PlatformControllerUpdateData
+  ): CancelablePromise<PlatformControllerUpdateResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/market/symbols/{dataSource}/{symbol}',
+      method: 'PUT',
+      url: '/api/v1/bean/platforms/{id}',
       path: {
-        dataSource: data.dataSource,
-        symbol: data.symbol,
-        region: data.region
-      },
-      query: {
-        includeHistoricalData: data.includeHistoricalData
+        id: data.id
       },
+      body: data.requestBody,
+      mediaType: 'application/json',
       errors: {
-        400: 'Invalid data source',
-        404: 'Symbol not found'
+        404: 'Platform not found'
       }
     });
   }
 
   /**
-   * Gather symbol data for specific date
-   * Retrieve historical symbol data for a specific date
+   * Delete a platform
    * @param data The data for the request.
-   * @param data.dataSource Data source provider
-   * @param data.dateString Date in ISO 8601 format (YYYY-MM-DD)
-   * @param data.symbol Symbol identifier (e.g., ticker code)
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown Historical data retrieved successfully
+   * @param data.id Platform ID
+   * @returns void Platform deleted successfully
    * @throws ApiError
    */
-  public static symbolControllerGatherSymbolForDate(
-    data: SymbolControllerGatherSymbolForDateData
-  ): CancelablePromise<SymbolControllerGatherSymbolForDateResponse> {
+  public static platformControllerDelete(
+    data: PlatformControllerDeleteData
+  ): CancelablePromise<PlatformControllerDeleteResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/market/symbols/{dataSource}/{symbol}/{dateString}',
+      method: 'DELETE',
+      url: '/api/v1/bean/platforms/{id}',
       path: {
-        dataSource: data.dataSource,
-        dateString: data.dateString,
-        symbol: data.symbol,
-        region: data.region
+        id: data.id
       },
       errors: {
-        400: 'Invalid date format',
-        404: 'Symbol data not found for specified date'
-      }
-    });
-  }
-
-  /**
-   * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
-   * @throws ApiError
-   */
-  public static symbolController(
-    data: SymbolControllerData
-  ): CancelablePromise<SymbolControllerResponse> {
-    return __request(OpenAPI, {
-      method: 'PUT',
-      url: '/api/v1/market/symbols/yahoo/batch-update',
-      path: {
-        region: data.region
-      }
-    });
-  }
-}
-
-export class DefaultService {
-  /**
-   * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
-   * @throws ApiError
-   */
-  public static cacheControllerFlushCache(
-    data: CacheControllerFlushCacheData
-  ): CancelablePromise<CacheControllerFlushCacheResponse> {
-    return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/cache/flush',
-      path: {
-        region: data.region
+        404: 'Platform not found'
       }
     });
   }
@@ -2744,7 +3822,7 @@ export class DashboardService {
    * 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 (cn, us, de)
+   * @param data.region Region code for tenant context
    * @param data.date Date for balance calculation (ISO 8601 format)
    * @returns NetWorthResponseDto Net worth retrieved successfully
    * @throws ApiError
@@ -2771,9 +3849,10 @@ export class DashboardService {
    * 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 (cn, us, de)
+   * @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.
    * @throws ApiError
    */
@@ -2788,159 +3867,105 @@ export class DashboardService {
       },
       query: {
         groupBy: data.groupBy,
-        date: data.date
-      },
-      errors: {
-        401: 'User not authenticated'
-      }
-    });
-  }
-
-  /**
-   * 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 (cn, us, de)
-   * @returns CashFlowResponseDto Cash flow retrieved successfully
-   * @throws ApiError
-   */
-  public static dashboardControllerGetCashFlow(
-    data: DashboardControllerGetCashFlowData
-  ): CancelablePromise<DashboardControllerGetCashFlowResponse> {
-    return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/{region}/dashboard/cash-flow',
-      path: {
-        region: data.region
-      },
-      query: {
-        period: data.period
-      },
-      errors: {
-        400: 'Invalid period format',
-        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)
-   *
+        date: data.date,
+        accountId: data.accountId
+      },
+      errors: {
+        401: 'User not authenticated'
+      }
+    });
+  }
+
+  /**
+   * Get cash flow summary
+   * Returns income, expenses, and savings for a monthly period
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @param data.period Time period
-   * @param data.granularity Data granularity
-   * @returns PortfolioTrendsResponseDto Trends retrieved successfully
+   * @param data.period Period in YYYY-MM format
+   * @param data.region Region code for tenant context
+   * @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 (cn, us, de)
-   * @param data.requestBody Optional date (defaults to today)
-   * @returns GenerateSnapshotResponse Snapshot generated successfully
+   * @param data.region Region code for tenant context
+   * @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 (cn, us, de)
-   * @param data.requestBody
-   * @returns BackfillSnapshotsResponse Backfill completed successfully
+   * @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
    * @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'
       }
     });
   }
@@ -2948,19 +3973,17 @@ export class ReportingService {
 
 export class ApiKeysService {
   /**
-   * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
+   * Create API key
+   * Generates a new API key for the authenticated user
+   * @returns unknown API key created successfully
    * @throws ApiError
    */
-  public static apiKeysController(
-    data: ApiKeysControllerData
-  ): CancelablePromise<ApiKeysControllerResponse> {
+  public static apiKeysControllerCreateApiKey(): CancelablePromise<ApiKeysControllerCreateApiKeyResponse> {
     return __request(OpenAPI, {
       method: 'POST',
       url: '/api/v1/auth/api-keys',
-      path: {
-        region: data.region
+      errors: {
+        403: 'Insufficient permissions to create API key'
       }
     });
   }
@@ -2970,9 +3993,8 @@ export class AuthService {
   /**
    * Anonymous login with access token
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
    * @param data.requestBody
-   * @returns unknown Login successful
+   * @returns AnonymousLoginResponseDto Login successful
    * @throws ApiError
    */
   public static authControllerAccessTokenLogin(
@@ -2981,9 +4003,6 @@ export class AuthService {
     return __request(OpenAPI, {
       method: 'POST',
       url: '/api/v1/auth/sessions/anonymous',
-      path: {
-        region: data.region
-      },
       body: data.requestBody,
       mediaType: 'application/json',
       errors: {
@@ -2993,6 +4012,19 @@ export class AuthService {
   }
 }
 
+export class DefaultService {
+  /**
+   * @returns unknown
+   * @throws ApiError
+   */
+  public static cacheControllerFlushCache(): CancelablePromise<CacheControllerFlushCacheResponse> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/cache/flush'
+    });
+  }
+}
+
 export class ExchangeRateService {
   /**
    * Get exchange rate for currency pair
@@ -3000,7 +4032,6 @@ export class ExchangeRateService {
    * @param data The data for the request.
    * @param data.symbol Currency pair symbol (e.g., USDCNY, EURUSD)
    * @param data.dateString Date in ISO format (YYYY-MM-DD)
-   * @param data.region Region code (cn, us, de)
    * @returns unknown Exchange rate retrieved successfully
    * @throws ApiError
    */
@@ -3012,8 +4043,7 @@ export class ExchangeRateService {
       url: '/api/v1/market/exchange-rates/{symbol}/{dateString}',
       path: {
         symbol: data.symbol,
-        dateString: data.dateString,
-        region: data.region
+        dateString: data.dateString
       },
       errors: {
         404: 'Exchange rate not found for the specified currency pair and date'
@@ -3025,20 +4055,13 @@ export class ExchangeRateService {
 export class HealthService {
   /**
    * Basic health check for K8s/load balancer probes
-   * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
    * @returns unknown Service is healthy
    * @throws ApiError
    */
-  public static healthControllerGetHealth(
-    data: HealthControllerGetHealthData
-  ): CancelablePromise<HealthControllerGetHealthResponse> {
+  public static healthControllerGetHealth(): CancelablePromise<HealthControllerGetHealthResponse> {
     return __request(OpenAPI, {
       method: 'GET',
       url: '/api/v1/health',
-      path: {
-        region: data.region
-      },
       errors: {
         503: 'Service unavailable'
       }
@@ -3047,42 +4070,43 @@ export class HealthService {
 
   /**
    * Check database connection health
-   * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
    * @returns unknown Database is healthy
    * @throws ApiError
    */
-  public static healthControllerCheckDatabase(
-    data: HealthControllerCheckDatabaseData
-  ): CancelablePromise<HealthControllerCheckDatabaseResponse> {
+  public static healthControllerCheckDatabase(): CancelablePromise<HealthControllerCheckDatabaseResponse> {
     return __request(OpenAPI, {
       method: 'GET',
       url: '/api/v1/health/database',
-      path: {
-        region: data.region
-      },
       errors: {
         503: 'Database unavailable'
       }
     });
   }
 
+  /**
+   * Check OpenBB schema status
+   * @returns unknown OpenBB status
+   * @throws ApiError
+   */
+  public static healthControllerCheckOpenBb(): CancelablePromise<HealthControllerCheckOpenBbResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/health/openbb',
+      errors: {
+        503: 'OpenBB unavailable'
+      }
+    });
+  }
+
   /**
    * Check Redis connection health
-   * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
    * @returns unknown Redis is healthy
    * @throws ApiError
    */
-  public static healthControllerCheckRedis(
-    data: HealthControllerCheckRedisData
-  ): CancelablePromise<HealthControllerCheckRedisResponse> {
+  public static healthControllerCheckRedis(): CancelablePromise<HealthControllerCheckRedisResponse> {
     return __request(OpenAPI, {
       method: 'GET',
       url: '/api/v1/health/redis',
-      path: {
-        region: data.region
-      },
       errors: {
         503: 'Redis unavailable'
       }
@@ -3091,20 +4115,13 @@ export class HealthService {
 
   /**
    * Get status of all circuit breakers
-   * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
    * @returns unknown Circuit breaker status
    * @throws ApiError
    */
-  public static healthControllerGetCircuitBreakersHealth(
-    data: HealthControllerGetCircuitBreakersHealthData
-  ): CancelablePromise<HealthControllerGetCircuitBreakersHealthResponse> {
+  public static healthControllerGetCircuitBreakersHealth(): CancelablePromise<HealthControllerGetCircuitBreakersHealthResponse> {
     return __request(OpenAPI, {
       method: 'GET',
       url: '/api/v1/health/circuit-breakers',
-      path: {
-        region: data.region
-      },
       errors: {
         401: 'Unauthorized',
         500: 'Internal error'
@@ -3116,7 +4133,6 @@ export class HealthService {
    * Reset a circuit breaker to CLOSED state
    * @param data The data for the request.
    * @param data.name Circuit breaker name to reset
-   * @param data.region Region code (cn, us, de)
    * @returns unknown Circuit breaker reset successfully
    * @throws ApiError
    */
@@ -3127,8 +4143,7 @@ export class HealthService {
       method: 'POST',
       url: '/api/v1/health/circuit-breakers/{name}/reset',
       path: {
-        name: data.name,
-        region: data.region
+        name: data.name
       },
       errors: {
         401: 'Unauthorized',
@@ -3139,222 +4154,79 @@ export class HealthService {
 
   /**
    * Get health check metrics and statistics
-   * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
    * @returns unknown Health metrics
    * @throws ApiError
    */
-  public static healthControllerGetMetrics(
-    data: HealthControllerGetMetricsData
-  ): CancelablePromise<HealthControllerGetMetricsResponse> {
+  public static healthControllerGetMetrics(): CancelablePromise<HealthControllerGetMetricsResponse> {
     return __request(OpenAPI, {
       method: 'GET',
       url: '/api/v1/health/metrics',
-      path: {
-        region: data.region
-      },
       errors: {
         401: 'Unauthorized'
       }
     });
   }
-
-  /**
-   * Check health of a specific data enhancer
-   * @param data The data for the request.
-   * @param data.name Data enhancer name
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown Data enhancer is healthy
-   * @throws ApiError
-   */
-  public static healthControllerGetHealthOfDataEnhancer(
-    data: HealthControllerGetHealthOfDataEnhancerData
-  ): CancelablePromise<HealthControllerGetHealthOfDataEnhancerResponse> {
-    return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/health/data-enhancer/{name}',
-      path: {
-        name: data.name,
-        region: data.region
-      },
-      errors: {
-        401: 'Unauthorized',
-        503: 'Data enhancer unavailable'
-      }
-    });
-  }
-
-  /**
-   * Check health of all data providers
-   * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown Data providers health status
-   * @throws ApiError
-   */
-  public static healthControllerCheckDataProviders(
-    data: HealthControllerCheckDataProvidersData
-  ): CancelablePromise<HealthControllerCheckDataProvidersResponse> {
-    return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/health/data-providers',
-      path: {
-        region: data.region
-      },
-      errors: {
-        401: 'Unauthorized',
-        503: 'Data providers check failed'
-      }
-    });
-  }
-
-  /**
-   * Check health of a specific data provider
-   * @param data The data for the request.
-   * @param data.dataSource Data source identifier
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown Data provider is healthy
-   * @throws ApiError
-   */
-  public static healthControllerGetHealthOfDataProvider(
-    data: HealthControllerGetHealthOfDataProviderData
-  ): CancelablePromise<HealthControllerGetHealthOfDataProviderResponse> {
-    return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/health/data-provider/{dataSource}',
-      path: {
-        dataSource: data.dataSource,
-        region: data.region
-      },
-      errors: {
-        400: 'Invalid data source',
-        401: 'Unauthorized',
-        503: 'Data provider unavailable'
-      }
-    });
-  }
 }
 
 export class InfoService {
   /**
    * Get system information
-   * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
    * @returns unknown System information retrieved successfully
    * @throws ApiError
    */
-  public static infoControllerGetInfo(
-    data: InfoControllerGetInfoData
-  ): CancelablePromise<InfoControllerGetInfoResponse> {
+  public static infoControllerGetInfo(): CancelablePromise<InfoControllerGetInfoResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/system/info',
-      path: {
-        region: data.region
-      }
+      url: '/api/v1/system/info'
     });
   }
 }
 
-export class LogosService {
-  /**
-   * Get asset logo by data source and symbol
-   * @param data The data for the request.
-   * @param data.dataSource Data source identifier (e.g., YAHOO, COINGECKO)
-   * @param data.symbol Asset symbol (e.g., AAPL, BTC)
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown Logo image stream (favicon)
-   * @throws ApiError
-   */
-  public static logoControllerGetLogoByDataSourceAndSymbol(
-    data: LogoControllerGetLogoByDataSourceAndSymbolData
-  ): CancelablePromise<LogoControllerGetLogoByDataSourceAndSymbolResponse> {
-    return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/market/logos/{dataSource}/{symbol}',
-      path: {
-        dataSource: data.dataSource,
-        symbol: data.symbol,
-        region: data.region
-      },
-      errors: {
-        401: 'Unauthorized',
-        404: 'Logo not found for the specified asset',
-        503: 'Service unavailable'
-      }
-    });
-  }
-
+export class MarketDataService {
   /**
-   * Get website favicon by URL
+   * 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.url Website URL to fetch favicon from
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown Logo image stream (favicon)
+   * @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 logoControllerGetLogoByUrl(
-    data: LogoControllerGetLogoByUrlData
-  ): CancelablePromise<LogoControllerGetLogoByUrlResponse> {
+  public static symbolControllerSearch(
+    data: SymbolControllerSearchData
+  ): CancelablePromise<SymbolControllerSearchResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/market/logos',
-      path: {
-        region: data.region
-      },
+      url: '/api/v1/market/symbols/search',
       query: {
-        url: data.url
-      },
-      errors: {
-        401: 'Unauthorized',
-        503: 'Service unavailable'
+        q: data.q,
+        limit: data.limit,
+        exchange: data.exchange,
+        assetType: data.assetType
       }
     });
   }
-}
 
-export class MarketDataService {
   /**
-   * Get market data by symbol
-   * Retrieves market data and asset profile for a given symbol and data source
+   * Get a market symbol quote
    * @param data The data for the request.
-   * @param data.dataSource Data source provider
-   * @param data.symbol Symbol code
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown Market data retrieved successfully
+   * @param data.symbol
+   * @returns SymbolQuoteDto Symbol quote
    * @throws ApiError
    */
-  public static marketDataControllerGetMarketDataBySymbol(
-    data: MarketDataControllerGetMarketDataBySymbolData
-  ): CancelablePromise<MarketDataControllerGetMarketDataBySymbolResponse> {
+  public static symbolControllerGetQuote(
+    data: SymbolControllerGetQuoteData
+  ): CancelablePromise<SymbolControllerGetQuoteResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/market-data/{dataSource}/{symbol}',
+      url: '/api/v1/market/symbols/{symbol}/quote',
       path: {
-        dataSource: data.dataSource,
-        symbol: data.symbol,
-        region: data.region
+        symbol: data.symbol
       },
       errors: {
-        403: 'Insufficient permissions to read market data',
-        404: 'Market data not found'
-      }
-    });
-  }
-
-  /**
-   * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
-   * @returns unknown
-   * @throws ApiError
-   */
-  public static marketDataController(
-    data: MarketDataControllerData
-  ): CancelablePromise<MarketDataControllerResponse> {
-    return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/market-data/{dataSource}/{symbol}',
-      path: {
-        region: data.region
+        404: 'Symbol not found in the openbb catalog'
       }
     });
   }