@firela/api-types 0.0.0-canary.fb3ac1dd → 0.0.0-canary.fd60e04

package/src/generated/services.gen.ts

@@ -57,6 +57,48 @@ import type {
   ReviewControllerUndoResponse,
   ReviewControllerBatchResolveData,
   ReviewControllerBatchResolveResponse,
+  TransactionRuleControllerCreateData,
+  TransactionRuleControllerCreateResponse,
+  TransactionRuleControllerListData,
+  TransactionRuleControllerListResponse,
+  TransactionRuleControllerValidateData,
+  TransactionRuleControllerValidateResponse,
+  TransactionRuleControllerBulkCreateData,
+  TransactionRuleControllerBulkCreateResponse,
+  TransactionRuleControllerExportData,
+  TransactionRuleControllerExportResponse,
+  TransactionRuleControllerGetStatisticsData,
+  TransactionRuleControllerGetStatisticsResponse,
+  TransactionRuleControllerGetDetailData,
+  TransactionRuleControllerGetDetailResponse,
+  TransactionRuleControllerUpdateData,
+  TransactionRuleControllerUpdateResponse,
+  TransactionRuleControllerDeleteData,
+  TransactionRuleControllerDeleteResponse,
+  TransactionRuleControllerTestData,
+  TransactionRuleControllerTestResponse,
+  UserControllerDeleteOwnUserData,
+  UserControllerDeleteOwnUserResponse,
+  UserControllerGetUserData,
+  UserControllerGetUserResponse,
+  UserControllerSignupUserData,
+  UserControllerSignupUserResponse,
+  UserControllerDeleteUserData,
+  UserControllerDeleteUserResponse,
+  UserControllerGetUserInfoData,
+  UserControllerGetUserInfoResponse,
+  UserControllerUpdateUserSettingData,
+  UserControllerUpdateUserSettingResponse,
+  UserControllerGetAllUserSettingsByPageData,
+  UserControllerGetAllUserSettingsByPageResponse,
+  UserControllerGetAssetLiabilitySummaryResponse,
+  PropertyControllerGetAllResponse,
+  PropertyControllerGetByKeyData,
+  PropertyControllerGetByKeyResponse,
+  PropertyControllerUpdateData,
+  PropertyControllerUpdateResponse,
+  PropertyControllerDeleteData,
+  PropertyControllerDeleteResponse,
   PayeeControllerCreateData,
   PayeeControllerCreateResponse,
   PayeeControllerFindAllData,
@@ -85,6 +127,7 @@ import type {
   PayeeProfileAdminControllerVerifyResponse,
   PayeeProfileAdminControllerUnverifyData,
   PayeeProfileAdminControllerUnverifyResponse,
+  PayeeProfileControllerListActiveResponse,
   CommodityControllerCreateData,
   CommodityControllerCreateResponse,
   CommodityControllerFindAllData,
@@ -99,6 +142,14 @@ import type {
   CommodityControllerGetOrCreateResponse,
   CommodityControllerBulkCreateData,
   CommodityControllerBulkCreateResponse,
+  ReportingControllerGetPortfolioTrendsData,
+  ReportingControllerGetPortfolioTrendsResponse,
+  ReportingControllerGetCashFlowTrendsData,
+  ReportingControllerGetCashFlowTrendsResponse,
+  ReportingControllerGenerateSnapshotData,
+  ReportingControllerGenerateSnapshotResponse,
+  ReportingControllerBackfillSnapshotsData,
+  ReportingControllerBackfillSnapshotsResponse,
   PriceControllerCreateData,
   PriceControllerCreateResponse,
   PriceControllerFindAllData,
@@ -143,56 +194,8 @@ import type {
   ExpectedTransactionControllerEnterNowResponse,
   ForecastControllerGetForecastData,
   ForecastControllerGetForecastResponse,
-  ReportingControllerGetPortfolioTrendsData,
-  ReportingControllerGetPortfolioTrendsResponse,
-  ReportingControllerGetCashFlowTrendsData,
-  ReportingControllerGetCashFlowTrendsResponse,
-  ReportingControllerGenerateSnapshotData,
-  ReportingControllerGenerateSnapshotResponse,
-  ReportingControllerBackfillSnapshotsData,
-  ReportingControllerBackfillSnapshotsResponse,
-  UserControllerDeleteOwnUserData,
-  UserControllerDeleteOwnUserResponse,
-  UserControllerGetUserData,
-  UserControllerGetUserResponse,
-  UserControllerSignupUserData,
-  UserControllerSignupUserResponse,
-  UserControllerDeleteUserData,
-  UserControllerDeleteUserResponse,
-  UserControllerGetUserInfoData,
-  UserControllerGetUserInfoResponse,
-  UserControllerUpdateUserSettingData,
-  UserControllerUpdateUserSettingResponse,
-  UserControllerGetAllUserSettingsByPageData,
-  UserControllerGetAllUserSettingsByPageResponse,
-  UserControllerGetAssetLiabilitySummaryResponse,
-  PropertyControllerGetAllResponse,
-  PropertyControllerGetByKeyData,
-  PropertyControllerGetByKeyResponse,
-  PropertyControllerUpdateData,
-  PropertyControllerUpdateResponse,
-  PropertyControllerDeleteData,
-  PropertyControllerDeleteResponse,
-  TransactionRuleControllerCreateData,
-  TransactionRuleControllerCreateResponse,
-  TransactionRuleControllerListData,
-  TransactionRuleControllerListResponse,
-  TransactionRuleControllerValidateData,
-  TransactionRuleControllerValidateResponse,
-  TransactionRuleControllerBulkCreateData,
-  TransactionRuleControllerBulkCreateResponse,
-  TransactionRuleControllerExportData,
-  TransactionRuleControllerExportResponse,
-  TransactionRuleControllerGetStatisticsData,
-  TransactionRuleControllerGetStatisticsResponse,
-  TransactionRuleControllerGetDetailData,
-  TransactionRuleControllerGetDetailResponse,
-  TransactionRuleControllerUpdateData,
-  TransactionRuleControllerUpdateResponse,
-  TransactionRuleControllerDeleteData,
-  TransactionRuleControllerDeleteResponse,
-  TransactionRuleControllerTestData,
-  TransactionRuleControllerTestResponse,
+  CategoryCatalogControllerListData,
+  CategoryCatalogControllerListResponse,
   EventControllerCreateData,
   EventControllerCreateResponse,
   EventControllerFindAllData,
@@ -215,6 +218,7 @@ import type {
   ReconciliationControllerPadResponse,
   ReconciliationControllerHistoryData,
   ReconciliationControllerHistoryResponse,
+  ExportControllerExportBeancountData,
   ExportControllerExportBeancountResponse,
   FileImportControllerImportFileData,
   FileImportControllerImportFileResponse,
@@ -257,9 +261,12 @@ import type {
   PlatformControllerFindAllResponse,
   PlatformControllerCreateData,
   PlatformControllerCreateResponse,
+  PlatformControllerGetPlatformListData,
   PlatformControllerGetPlatformListResponse,
   PlatformControllerMatchPlatformsData,
   PlatformControllerMatchPlatformsResponse,
+  PlatformControllerGetPlatformStandardsData,
+  PlatformControllerGetPlatformStandardsResponse,
   PlatformControllerUpdateData,
   PlatformControllerUpdateResponse,
   PlatformControllerDeleteData,
@@ -272,11 +279,17 @@ import type {
   DashboardControllerGetCashFlowResponse,
   DashboardControllerGetExpensesData,
   DashboardControllerGetExpensesResponse,
+  DashboardControllerGetAdvisorContextData,
+  DashboardControllerGetAdvisorContextResponse,
   HoldingPnlControllerGetHoldingPnlData,
   HoldingPnlControllerGetHoldingPnlResponse,
   ApiKeysControllerCreateApiKeyResponse,
   AuthControllerAccessTokenLoginData,
   AuthControllerAccessTokenLoginResponse,
+  AuthControllerAdvisorTokenLoginData,
+  AuthControllerAdvisorTokenLoginResponse,
+  ParserContributionControllerCreateData,
+  ParserContributionControllerCreateResponse,
   CacheControllerFlushCacheResponse,
   ExchangeRateControllerGetExchangeRateData,
   ExchangeRateControllerGetExchangeRateResponse,
@@ -330,7 +343,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 account path
+   * @param data.search Search term matched against account path and user-set display name (case-insensitive)
    * @param data.limit Maximum number of results
    * @param data.offset Number of results to skip
    * @returns AccountListResponseDto Accounts retrieved successfully
@@ -526,11 +539,11 @@ export class BeanAccountsService {
 export class BeanAccountStandardsService {
   /**
    * Get account templates
-   * Returns predefined account templates for a region. Supports filtering by account type and search term.
+   * Returns predefined account templates for a region. Supports filtering by account type and search term. Not-yet-open region codes return the universal-only catalog (#759).
    * @param data The data for the request.
-   * @param data.region Region code (cn, us, de)
+   * @param data.region Region code (any ISO alpha-2; not-yet-open codes return the universal-only catalog)
    * @param data.type Filter by account type
-   * @param data.search Search term for path or description
+   * @param data.search Search term for path, description, aliases, or localized display name
    * @returns AccountStandardListResponseDto Account templates retrieved successfully
    * @throws ApiError
    */
@@ -554,7 +567,7 @@ export class BeanAccountStandardsService {
    * 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.region Region code for tenant context. Not-yet-open codes degrade to the universal-only catalog (#759)
    * @param data.path Account path to check
    * @returns TemplateMetadataResponseDto Template metadata retrieved successfully
    * @throws ApiError
@@ -576,9 +589,9 @@ export class BeanAccountStandardsService {
 
   /**
    * Get available regions with hierarchy
-   * Returns supported regions with inheritance metadata
+   * Returns the full region catalog (every ISO 3166-1 entry) with an 'open' flag and inheritance metadata (#759)
    * @param data The data for the request.
-   * @param data.region Region code for tenant context
+   * @param data.region Region code for tenant context. Not-yet-open codes degrade to the universal-only catalog (#759)
    * @returns RegionsMetadataResponseDto Regions metadata retrieved successfully
    * @throws ApiError
    */
@@ -635,10 +648,11 @@ export class BeanTransactionsService {
    * @param data.offset Number of items to skip (default: 0)
    * @param data.dateFrom Filter by start date (inclusive), format: YYYY-MM-DD
    * @param data.dateTo Filter by end date (inclusive), format: YYYY-MM-DD
-   * @param data.status Filter by transaction status
+   * @param data.status Filter by transaction status: single value, comma-separated multi-value (e.g. VOIDED,SUPERSEDED), or ALL to include audit rows. Defaults to ACTIVE-only (ADR-0128; previously unfiltered — breaking change).
    * @param data.search Search in narration and payee fields (max 200 chars)
    * @param data.accountId Filter by account ID (transactions with postings to this account)
-   * @param data.category Filter by ADR-0075 functional category (Group segment); matches any posting to an Expenses/Income account whose derived Group segment equals this value
+   * @param data.category Filter by ADR-0075 functional category (Group segment); matches any posting to an account whose derived Group segment equals this value. Must be accompanied by flow (ADR-0126).
+   * @param data.flow Required when category is present (400 otherwise) and vice versa (ADR-0126). Restricts the category account set to the flow root (income → Income:, expense → Expenses:) and drives the per-leg sign normalization of row viewpointAmount and the summary. OpenAPI cannot express conditional requiredness — the pairing is enforced at runtime.
    * @returns TransactionListResponseDto Transaction list
    * @throws ApiError
    */
@@ -659,7 +673,8 @@ export class BeanTransactionsService {
         status: data.status,
         search: data.search,
         accountId: data.accountId,
-        category: data.category
+        category: data.category,
+        flow: data.flow
       },
       errors: {
         400: 'Validation failed',
@@ -1040,1126 +1055,1080 @@ export class BeanReviewsService {
   }
 }
 
-export class BeanPayeesService {
+export class BeanTransactionRulesService {
   /**
-   * Create a new payee
-   * Creates a new payee mapping for the authenticated user. The payee name must be unique within the user's account.
+   * 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 for tenant context
    * @param data.requestBody
-   * @returns PayeeResponseDto Payee created successfully
+   * @returns TransactionRuleResponseDto Rule updated successfully (upsert mode)
    * @throws ApiError
    */
-  public static payeeControllerCreate(
-    data: PayeeControllerCreateData
-  ): CancelablePromise<PayeeControllerCreateResponse> {
+  public static transactionRuleControllerCreate(
+    data: TransactionRuleControllerCreateData
+  ): CancelablePromise<TransactionRuleControllerCreateResponse> {
     return __request(OpenAPI, {
       method: 'POST',
-      url: '/api/v1/bean/payees',
+      url: '/api/v1/{region}/bean/transaction-rules',
+      path: {
+        region: data.region
+      },
       body: data.requestBody,
       mediaType: 'application/json',
       errors: {
-        400: 'Invalid input data',
-        409: 'Payee already exists'
+        400: 'Validation failed',
+        401: 'Unauthorized',
+        409: 'Resource conflict - another process is updating this rule'
       }
     });
   }
 
   /**
-   * List user payees
-   * Returns all payee mappings for the authenticated user with optional filtering
+   * Get all transaction rules for user
    * @param data The data for the request.
-   * @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
-   * @param data.tag Filter by custom tag (returns payees that have this tag)
-   * @param data.isActive Filter by active status. Defaults to true (show only active payees).
-   * @returns PayeeListResponseDto Payees retrieved successfully
+   * @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
+   * @param data.learningSource Filter by learning source. Omit this parameter or pass empty string to get manually created rules (learningSource is null in database).
+   * @param data.autoApplyEnabled Filter by auto-apply status
+   * @returns TransactionRuleListResponseDto List of rules
    * @throws ApiError
    */
-  public static payeeControllerFindAll(
-    data: PayeeControllerFindAllData = {}
-  ): CancelablePromise<PayeeControllerFindAllResponse> {
+  public static transactionRuleControllerList(
+    data: TransactionRuleControllerListData
+  ): CancelablePromise<TransactionRuleControllerListResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/bean/payees',
+      url: '/api/v1/{region}/bean/transaction-rules',
+      path: {
+        region: data.region
+      },
       query: {
-        search: data.search,
-        payee: data.payee,
-        category: data.category,
-        tag: data.tag,
-        isActive: data.isActive
+        limit: data.limit,
+        offset: data.offset,
+        enabled: data.enabled,
+        learningSource: data.learningSource,
+        autoApplyEnabled: data.autoApplyEnabled
+      },
+      errors: {
+        401: 'Unauthorized'
       }
     });
   }
 
   /**
-   * Get payee autocomplete suggestions
-   * Returns active payee names matching the query, sorted by recent usage. Used for transaction input autocomplete.
+   * Validate transaction rule configuration
    * @param data The data for the request.
-   * @param data.q Search query for payee name (partial match, case-insensitive)
-   * @param data.limit Maximum number of suggestions
-   * @returns PayeeAutocompleteResponseDto Autocomplete suggestions retrieved successfully
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns ValidateRuleResponseDto Validation result
    * @throws ApiError
    */
-  public static payeeControllerAutocomplete(
-    data: PayeeControllerAutocompleteData
-  ): CancelablePromise<PayeeControllerAutocompleteResponse> {
+  public static transactionRuleControllerValidate(
+    data: TransactionRuleControllerValidateData
+  ): CancelablePromise<TransactionRuleControllerValidateResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/bean/payees/autocomplete',
-      query: {
-        q: data.q,
-        limit: data.limit
+      method: 'POST',
+      url: '/api/v1/{region}/bean/transaction-rules/validate',
+      path: {
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: 'Validation failed',
+        401: 'Unauthorized'
       }
     });
   }
 
   /**
-   * Get top payees by usage
-   * Returns the most frequently used payees, sorted by use count. Used for statistics and analytics.
+   * Bulk create transaction rules
    * @param data The data for the request.
-   * @param data.limit Maximum number of results
-   * @returns PayeeStatsResponseDto Top payees retrieved successfully
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns BulkCreateRulesResponseDto Bulk create completed
    * @throws ApiError
    */
-  public static payeeControllerGetTopPayees(
-    data: PayeeControllerGetTopPayeesData = {}
-  ): CancelablePromise<PayeeControllerGetTopPayeesResponse> {
+  public static transactionRuleControllerBulkCreate(
+    data: TransactionRuleControllerBulkCreateData
+  ): CancelablePromise<TransactionRuleControllerBulkCreateResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/bean/payees/top',
-      query: {
-        limit: data.limit
+      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'
       }
     });
   }
 
   /**
-   * Get payee by ID
-   * Returns a specific payee mapping by its UUID
+   * Export transaction rules
    * @param data The data for the request.
-   * @param data.id Payee UUID
-   * @returns PayeeResponseDto Payee retrieved successfully
+   * @param data.format Export format (currently only JSON supported)
+   * @param data.region Region code for tenant context
+   * @returns ExportRulesResponseDto Exported rules
    * @throws ApiError
    */
-  public static payeeControllerFindOne(
-    data: PayeeControllerFindOneData
-  ): CancelablePromise<PayeeControllerFindOneResponse> {
+  public static transactionRuleControllerExport(
+    data: TransactionRuleControllerExportData
+  ): CancelablePromise<TransactionRuleControllerExportResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/bean/payees/{id}',
+      url: '/api/v1/{region}/bean/transaction-rules/export/{format}',
       path: {
-        id: data.id
+        format: data.format,
+        region: data.region
       },
       errors: {
-        403: 'Payee belongs to another user',
-        404: 'Payee not found'
+        400: 'Unsupported format',
+        401: 'Unauthorized'
       }
     });
   }
 
   /**
-   * Update payee
-   * Updates a payee mapping. The payee name cannot be changed after creation.
+   * Get transaction rule statistics
    * @param data The data for the request.
-   * @param data.id Payee UUID
-   * @param data.requestBody
-   * @returns PayeeResponseDto Payee updated successfully
+   * @param data.period Statistics time period
+   * @param data.region Region code for tenant context
+   * @returns RuleStatisticsResponseDto Rule statistics
    * @throws ApiError
    */
-  public static payeeControllerUpdate(
-    data: PayeeControllerUpdateData
-  ): CancelablePromise<PayeeControllerUpdateResponse> {
+  public static transactionRuleControllerGetStatistics(
+    data: TransactionRuleControllerGetStatisticsData
+  ): CancelablePromise<TransactionRuleControllerGetStatisticsResponse> {
     return __request(OpenAPI, {
-      method: 'PUT',
-      url: '/api/v1/bean/payees/{id}',
+      method: 'GET',
+      url: '/api/v1/{region}/bean/transaction-rules/statistics/{period}',
       path: {
-        id: data.id
+        period: data.period,
+        region: data.region
       },
-      body: data.requestBody,
-      mediaType: 'application/json',
       errors: {
-        400: 'Invalid input data',
-        404: 'Payee not found'
+        401: 'Unauthorized'
       }
     });
   }
 
   /**
-   * Delete payee
-   * Soft deletes a payee by marking it as inactive. Inactive payees will not appear in autocomplete suggestions.
+   * Get transaction rule detail
    * @param data The data for the request.
-   * @param data.id Payee UUID
-   * @returns void Payee deleted successfully
+   * @param data.ruleId Rule ID
+   * @param data.region Region code for tenant context
+   * @returns TransactionRuleResponseDto Rule details
    * @throws ApiError
    */
-  public static payeeControllerDelete(
-    data: PayeeControllerDeleteData
-  ): CancelablePromise<PayeeControllerDeleteResponse> {
+  public static transactionRuleControllerGetDetail(
+    data: TransactionRuleControllerGetDetailData
+  ): CancelablePromise<TransactionRuleControllerGetDetailResponse> {
     return __request(OpenAPI, {
-      method: 'DELETE',
-      url: '/api/v1/bean/payees/{id}',
+      method: 'GET',
+      url: '/api/v1/{region}/bean/transaction-rules/{ruleId}',
       path: {
-        id: data.id
+        ruleId: data.ruleId,
+        region: data.region
       },
       errors: {
-        404: 'Payee not found'
+        401: 'Unauthorized',
+        403: 'Forbidden - not owner of rule',
+        404: 'Rule not found'
       }
     });
   }
-}
 
-export class AdminPayeeProfilesService {
   /**
-   * Create payee profile (Admin only)
-   * Creates a new global payee profile. The canonical name must be unique (case-insensitive).
+   * Update a transaction rule
    * @param data The data for the request.
+   * @param data.ruleId Rule ID to update
+   * @param data.region Region code for tenant context
    * @param data.requestBody
-   * @returns PayeeProfileResponseDto Payee profile created successfully
+   * @returns TransactionRuleResponseDto Rule updated successfully
    * @throws ApiError
    */
-  public static payeeProfileAdminControllerCreate(
-    data: PayeeProfileAdminControllerCreateData
-  ): CancelablePromise<PayeeProfileAdminControllerCreateResponse> {
+  public static transactionRuleControllerUpdate(
+    data: TransactionRuleControllerUpdateData
+  ): CancelablePromise<TransactionRuleControllerUpdateResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/admin/payee-profiles',
+      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',
-        403: 'Admin access required',
-        409: 'Payee profile already exists'
+        401: 'Unauthorized',
+        403: 'Forbidden - not owner of rule',
+        404: 'Rule not found',
+        409: 'Resource conflict - rule is being modified by another process'
       }
     });
   }
 
   /**
-   * List payee profiles (Admin only)
-   * Returns all payee profiles with optional filtering by category, country, verification status, etc.
+   * Delete a transaction rule
    * @param data The data for the request.
-   * @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)
-   * @param data.isActive Filter by active status (default: true - show only active)
-   * @param data.verified Filter by verification status. true = verified only, false = unverified only
-   * @param data.dataSource Filter by data source
-   * @returns PayeeProfileListResponseDto Payee profiles retrieved successfully
+   * @param data.ruleId Rule ID to delete
+   * @param data.region Region code for tenant context
+   * @returns void Rule deleted successfully
    * @throws ApiError
    */
-  public static payeeProfileAdminControllerFindAll(
-    data: PayeeProfileAdminControllerFindAllData = {}
-  ): CancelablePromise<PayeeProfileAdminControllerFindAllResponse> {
+  public static transactionRuleControllerDelete(
+    data: TransactionRuleControllerDeleteData
+  ): CancelablePromise<TransactionRuleControllerDeleteResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/admin/payee-profiles',
-      query: {
-        search: data.search,
-        category: data.category,
-        country: data.country,
-        isActive: data.isActive,
-        verified: data.verified,
-        dataSource: data.dataSource
+      method: 'DELETE',
+      url: '/api/v1/{region}/bean/transaction-rules/{ruleId}',
+      path: {
+        ruleId: data.ruleId,
+        region: data.region
       },
       errors: {
-        403: 'Admin access required'
+        401: 'Unauthorized',
+        403: 'Forbidden - not owner of rule',
+        404: 'Rule not found',
+        409: 'Resource conflict - rule is being modified by another process'
       }
     });
   }
 
   /**
-   * Get payee profile by ID (Admin only)
-   * Returns a single payee profile by its ID.
+   * Test rule matching
    * @param data The data for the request.
-   * @param data.id Payee profile ID (UUID)
-   * @returns PayeeProfileResponseDto Payee profile retrieved successfully
+   * @param data.ruleId Rule ID to test
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns TestRuleResponseDto Test result
    * @throws ApiError
    */
-  public static payeeProfileAdminControllerFindOne(
-    data: PayeeProfileAdminControllerFindOneData
-  ): CancelablePromise<PayeeProfileAdminControllerFindOneResponse> {
+  public static transactionRuleControllerTest(
+    data: TransactionRuleControllerTestData
+  ): CancelablePromise<TransactionRuleControllerTestResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/admin/payee-profiles/{id}',
+      method: 'POST',
+      url: '/api/v1/{region}/bean/transaction-rules/{ruleId}/test',
       path: {
-        id: data.id
+        ruleId: data.ruleId,
+        region: data.region
       },
+      body: data.requestBody,
+      mediaType: 'application/json',
       errors: {
-        403: 'Admin access required',
-        404: 'Payee profile not found'
+        401: 'Unauthorized',
+        403: 'Forbidden - not owner of rule',
+        404: 'Rule not found'
       }
     });
   }
+}
 
+export class UsersService {
   /**
-   * Update payee profile (Admin only)
-   * Updates an existing payee profile. The canonical name cannot be changed.
+   * Delete own user account
    * @param data The data for the request.
-   * @param data.id Payee profile ID (UUID)
    * @param data.requestBody
-   * @returns PayeeProfileResponseDto Payee profile updated successfully
+   * @returns void User deleted successfully
    * @throws ApiError
    */
-  public static payeeProfileAdminControllerUpdate(
-    data: PayeeProfileAdminControllerUpdateData
-  ): CancelablePromise<PayeeProfileAdminControllerUpdateResponse> {
+  public static userControllerDeleteOwnUser(
+    data: UserControllerDeleteOwnUserData
+  ): CancelablePromise<UserControllerDeleteOwnUserResponse> {
     return __request(OpenAPI, {
-      method: 'PUT',
-      url: '/api/v1/admin/payee-profiles/{id}',
-      path: {
-        id: data.id
-      },
+      method: 'DELETE',
+      url: '/api/v1/users',
       body: data.requestBody,
       mediaType: 'application/json',
       errors: {
-        403: 'Admin access required',
-        404: 'Payee profile not found'
+        403: 'Invalid access token'
       }
     });
   }
 
   /**
-   * 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.
+   * Get current authenticated user
    * @param data The data for the request.
-   * @param data.id Payee profile ID (UUID)
-   * @returns void Payee profile deleted successfully
+   * @param data.acceptLanguage
+   * @returns UserResponseDto User retrieved successfully
    * @throws ApiError
    */
-  public static payeeProfileAdminControllerDelete(
-    data: PayeeProfileAdminControllerDeleteData
-  ): CancelablePromise<PayeeProfileAdminControllerDeleteResponse> {
+  public static userControllerGetUser(
+    data: UserControllerGetUserData
+  ): CancelablePromise<UserControllerGetUserResponse> {
     return __request(OpenAPI, {
-      method: 'DELETE',
-      url: '/api/v1/admin/payee-profiles/{id}',
-      path: {
-        id: data.id
-      },
-      errors: {
-        403: 'Admin access required',
-        404: 'Payee profile not found',
-        409: 'Payee profile is in use and cannot be deleted'
+      method: 'GET',
+      url: '/api/v1/users',
+      headers: {
+        'accept-language': data.acceptLanguage
       }
     });
   }
 
   /**
-   * Verify payee profile (Admin only)
-   * Marks a payee profile as verified by setting verifiedAt to current timestamp.
+   * 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.id Payee profile ID (UUID)
-   * @returns PayeeProfileResponseDto Payee profile verified successfully
+   * @param data.requestBody
+   * @returns SignupResponseDto User created successfully
    * @throws ApiError
    */
-  public static payeeProfileAdminControllerVerify(
-    data: PayeeProfileAdminControllerVerifyData
-  ): CancelablePromise<PayeeProfileAdminControllerVerifyResponse> {
+  public static userControllerSignupUser(
+    data: UserControllerSignupUserData
+  ): CancelablePromise<UserControllerSignupUserResponse> {
     return __request(OpenAPI, {
       method: 'POST',
-      url: '/api/v1/admin/payee-profiles/{id}/verify',
-      path: {
-        id: data.id
-      },
+      url: '/api/v1/users',
+      body: data.requestBody,
+      mediaType: 'application/json',
       errors: {
-        403: 'Admin access required',
-        404: 'Payee profile not found'
+        400: 'Invalid Turnstile token (when Turnstile is enabled)',
+        403: 'User signup is disabled'
       }
     });
   }
 
   /**
-   * Unverify payee profile (Admin only)
-   * Removes verification status by setting verifiedAt to null.
+   * Delete user by ID (admin only)
    * @param data The data for the request.
-   * @param data.id Payee profile ID (UUID)
-   * @returns PayeeProfileResponseDto Payee profile unverified successfully
+   * @param data.id User ID to delete
+   * @returns void User deleted successfully
    * @throws ApiError
    */
-  public static payeeProfileAdminControllerUnverify(
-    data: PayeeProfileAdminControllerUnverifyData
-  ): CancelablePromise<PayeeProfileAdminControllerUnverifyResponse> {
+  public static userControllerDeleteUser(
+    data: UserControllerDeleteUserData
+  ): CancelablePromise<UserControllerDeleteUserResponse> {
     return __request(OpenAPI, {
       method: 'DELETE',
-      url: '/api/v1/admin/payee-profiles/{id}/verify',
+      url: '/api/v1/users/{id}',
       path: {
         id: data.id
       },
       errors: {
-        403: 'Admin access required',
-        404: 'Payee profile not found'
+        403: 'Cannot delete own account or insufficient permissions'
       }
     });
   }
-}
 
-export class BeanCommoditiesService {
   /**
-   * Create a new commodity
-   * Creates a new commodity definition for the authenticated user
+   * Get user info by user ID
    * @param data The data for the request.
-   * @param data.region Region code for tenant context
-   * @param data.requestBody
-   * @returns CommodityResponseDto Commodity created successfully
+   * @param data.id User ID
+   * @returns unknown User info retrieved successfully
    * @throws ApiError
    */
-  public static commodityControllerCreate(
-    data: CommodityControllerCreateData
-  ): CancelablePromise<CommodityControllerCreateResponse> {
+  public static userControllerGetUserInfo(
+    data: UserControllerGetUserInfoData
+  ): CancelablePromise<UserControllerGetUserInfoResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/{region}/bean/commodities',
+      method: 'GET',
+      url: '/api/v1/users/{id}/info',
       path: {
-        region: data.region
+        id: data.id
       },
-      body: data.requestBody,
+      errors: {
+        403: 'Cannot access other user info without admin permission'
+      }
+    });
+  }
+
+  /**
+   * Update user settings
+   * @param data The data for the request.
+   * @param data.requestBody
+   * @returns unknown Settings updated successfully
+   * @throws ApiError
+   */
+  public static userControllerUpdateUserSetting(
+    data: UserControllerUpdateUserSettingData
+  ): CancelablePromise<UserControllerUpdateUserSettingResponse> {
+    return __request(OpenAPI, {
+      method: 'PUT',
+      url: '/api/v1/users/setting',
+      body: data.requestBody,
       mediaType: 'application/json',
       errors: {
-        400: 'Invalid input data',
-        409: 'Commodity already exists'
+        403: 'Insufficient permissions'
       }
     });
   }
 
   /**
-   * List user commodities
-   * Returns all commodity definitions for the authenticated user with optional filtering
+   * Get all user settings paginated (admin only)
    * @param data The data for the request.
-   * @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
+   * @param data.pageNo Page number
+   * @param data.pageSize Page size
+   * @returns unknown Settings list retrieved successfully
    * @throws ApiError
    */
-  public static commodityControllerFindAll(
-    data: CommodityControllerFindAllData
-  ): CancelablePromise<CommodityControllerFindAllResponse> {
+  public static userControllerGetAllUserSettingsByPage(
+    data: UserControllerGetAllUserSettingsByPageData
+  ): CancelablePromise<UserControllerGetAllUserSettingsByPageResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/{region}/bean/commodities',
-      path: {
-        region: data.region
-      },
+      url: '/api/v1/users/settings-by-page',
       query: {
-        search: data.search,
-        symbol: data.symbol
+        pageNo: data.pageNo,
+        pageSize: data.pageSize
       }
     });
   }
 
   /**
-   * Get commodity by symbol
-   * 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 for tenant context
-   * @returns CommodityResponseDto Commodity retrieved successfully
+   * Get asset and liability summary for current user
+   * @returns unknown Summary retrieved successfully
    * @throws ApiError
    */
-  public static commodityControllerFindOne(
-    data: CommodityControllerFindOneData
-  ): CancelablePromise<CommodityControllerFindOneResponse> {
+  public static userControllerGetAssetLiabilitySummary(): CancelablePromise<UserControllerGetAssetLiabilitySummaryResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/{region}/bean/commodities/{symbol}',
-      path: {
-        symbol: data.symbol,
-        region: data.region
-      },
-      errors: {
-        404: 'Commodity not found'
-      }
+      url: '/api/v1/users/asset-liability-summary'
     });
   }
+}
 
+export class PropertiesService {
   /**
-   * Update commodity
-   * Updates an existing commodity definition. Symbol cannot be changed.
-   * @param data The data for the request.
-   * @param data.symbol Commodity symbol
-   * @param data.region Region code for tenant context
-   * @param data.requestBody
-   * @returns CommodityResponseDto Commodity updated successfully
+   * Get all system properties
+   * @returns unknown Properties retrieved successfully
    * @throws ApiError
    */
-  public static commodityControllerUpdate(
-    data: CommodityControllerUpdateData
-  ): CancelablePromise<CommodityControllerUpdateResponse> {
+  public static propertyControllerGetAll(): CancelablePromise<PropertyControllerGetAllResponse> {
     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',
+      method: 'GET',
+      url: '/api/v1/admin/properties',
       errors: {
-        400: 'Invalid input data',
-        404: 'Commodity not found'
+        401: 'Unauthorized',
+        403: 'Forbidden - insufficient permissions'
       }
     });
   }
 
   /**
-   * Delete commodity
-   * Deletes a commodity definition
+   * Get property by key
    * @param data The data for the request.
-   * @param data.symbol Commodity symbol
-   * @param data.region Region code for tenant context
-   * @returns void Commodity deleted successfully
+   * @param data.key Property key
+   * @returns unknown Property retrieved successfully
    * @throws ApiError
    */
-  public static commodityControllerDelete(
-    data: CommodityControllerDeleteData
-  ): CancelablePromise<CommodityControllerDeleteResponse> {
+  public static propertyControllerGetByKey(
+    data: PropertyControllerGetByKeyData
+  ): CancelablePromise<PropertyControllerGetByKeyResponse> {
     return __request(OpenAPI, {
-      method: 'DELETE',
-      url: '/api/v1/{region}/bean/commodities/{symbol}',
+      method: 'GET',
+      url: '/api/v1/admin/properties/{key}',
       path: {
-        symbol: data.symbol,
-        region: data.region
+        key: data.key
       },
       errors: {
-        404: 'Commodity not found'
+        401: 'Unauthorized',
+        403: 'Forbidden - insufficient permissions',
+        404: 'Property not found'
       }
     });
   }
 
   /**
-   * Ensure commodity exists
-   * Gets existing commodity or creates it with automatic initialization from OpenBB
+   * Update a system property
    * @param data The data for the request.
-   * @param data.symbol Commodity symbol
-   * @param data.region Region code for tenant context
-   * @returns CommodityResponseDto Commodity retrieved or created
+   * @param data.key Property key
+   * @param data.requestBody
+   * @returns unknown Property updated successfully
    * @throws ApiError
    */
-  public static commodityControllerGetOrCreate(
-    data: CommodityControllerGetOrCreateData
-  ): CancelablePromise<CommodityControllerGetOrCreateResponse> {
+  public static propertyControllerUpdate(
+    data: PropertyControllerUpdateData
+  ): CancelablePromise<PropertyControllerUpdateResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/{region}/bean/commodities/{symbol}/ensure',
+      method: 'PUT',
+      url: '/api/v1/admin/properties/{key}',
       path: {
-        symbol: data.symbol,
-        region: data.region
+        key: data.key
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        401: 'Unauthorized',
+        403: 'Forbidden - insufficient permissions'
       }
     });
   }
 
   /**
-   * Bulk create commodities
-   * Creates multiple commodities from a list of symbols, useful for initialization
+   * Delete a system property
    * @param data The data for the request.
-   * @param data.region Region code for tenant context
-   * @returns CommodityResponseDto Commodities created successfully
+   * @param data.key Property key
+   * @returns void Property deleted successfully
    * @throws ApiError
    */
-  public static commodityControllerBulkCreate(
-    data: CommodityControllerBulkCreateData
-  ): CancelablePromise<CommodityControllerBulkCreateResponse> {
+  public static propertyControllerDelete(
+    data: PropertyControllerDeleteData
+  ): CancelablePromise<PropertyControllerDeleteResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/{region}/bean/commodities/bulk',
+      method: 'DELETE',
+      url: '/api/v1/admin/properties/{key}',
       path: {
-        region: data.region
+        key: data.key
+      },
+      errors: {
+        401: 'Unauthorized',
+        403: 'Forbidden - insufficient permissions',
+        404: 'Property not found'
       }
     });
   }
 }
 
-export class BeanPricesService {
+export class BeanPayeesService {
   /**
-   * Create a new price
-   * Creates a new price entry for the authenticated user
+   * 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 for tenant context
    * @param data.requestBody
-   * @returns PriceResponseDto Price created successfully
+   * @returns PayeeResponseDto Payee created successfully
    * @throws ApiError
    */
-  public static priceControllerCreate(
-    data: PriceControllerCreateData
-  ): CancelablePromise<PriceControllerCreateResponse> {
+  public static payeeControllerCreate(
+    data: PayeeControllerCreateData
+  ): CancelablePromise<PayeeControllerCreateResponse> {
     return __request(OpenAPI, {
       method: 'POST',
-      url: '/api/v1/{region}/bean/prices',
-      path: {
-        region: data.region
-      },
+      url: '/api/v1/bean/payees',
       body: data.requestBody,
       mediaType: 'application/json',
       errors: {
-        404: 'Currency or quoteCurrency commodity not found',
-        409: 'Price already exists for this currency pair and date'
+        400: 'Invalid input data',
+        409: 'Payee already exists'
       }
     });
   }
 
   /**
-   * List user prices
-   * Returns all price entries for the authenticated user with optional filtering
+   * 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 for tenant context
-   * @param data.currency Filter by currency (e.g., BTC, AAPL, USD)
-   * @param data.quoteCurrency Filter by quote currency (pricing currency, e.g., USD, CNY)
-   * @param data.dateFrom Filter prices from this date (ISO 8601 format)
-   * @param data.dateTo Filter prices to this date (ISO 8601 format)
-   * @param data.search Search term for currency or quoteCurrency (case-insensitive partial match)
-   * @param data.page Page number for pagination (default: 1)
-   * @param data.limit Number of items per page (default: 20, max: 100)
-   * @returns PriceListResponseDto Prices retrieved successfully
+   * @param data.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
+   * @param data.tag Filter by custom tag (returns payees that have this tag)
+   * @param data.isActive Filter by active status. Defaults to true (show only active payees).
+   * @returns PayeeListResponseDto Payees retrieved successfully
    * @throws ApiError
    */
-  public static priceControllerFindAll(
-    data: PriceControllerFindAllData
-  ): CancelablePromise<PriceControllerFindAllResponse> {
+  public static payeeControllerFindAll(
+    data: PayeeControllerFindAllData = {}
+  ): CancelablePromise<PayeeControllerFindAllResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/{region}/bean/prices',
-      path: {
-        region: data.region
-      },
+      url: '/api/v1/bean/payees',
       query: {
-        currency: data.currency,
-        quoteCurrency: data.quoteCurrency,
-        dateFrom: data.dateFrom,
-        dateTo: data.dateTo,
         search: data.search,
-        page: data.page,
-        limit: data.limit
+        payee: data.payee,
+        category: data.category,
+        tag: data.tag,
+        isActive: data.isActive
       }
     });
   }
 
   /**
-   * Get price by ID
-   * Returns a single price entry by its ID
+   * Get payee autocomplete suggestions
+   * 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.id Price ID
-   * @param data.region Region code for tenant context
-   * @returns PriceResponseDto Price retrieved successfully
+   * @param data.q Search query for payee name (partial match, case-insensitive)
+   * @param data.limit Maximum number of suggestions
+   * @returns PayeeAutocompleteResponseDto Autocomplete suggestions retrieved successfully
    * @throws ApiError
    */
-  public static priceControllerFindOne(
-    data: PriceControllerFindOneData
-  ): CancelablePromise<PriceControllerFindOneResponse> {
+  public static payeeControllerAutocomplete(
+    data: PayeeControllerAutocompleteData
+  ): CancelablePromise<PayeeControllerAutocompleteResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/{region}/bean/prices/{id}',
-      path: {
-        id: data.id,
-        region: data.region
-      },
-      errors: {
-        404: 'Price not found'
+      url: '/api/v1/bean/payees/autocomplete',
+      query: {
+        q: data.q,
+        limit: data.limit
       }
     });
   }
 
   /**
-   * Update a price
-   * Updates an existing price entry
+   * 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.id Price ID
-   * @param data.region Region code for tenant context
-   * @param data.requestBody
-   * @returns PriceResponseDto Price updated successfully
+   * @param data.limit Maximum number of results
+   * @returns PayeeStatsResponseDto Top payees retrieved successfully
    * @throws ApiError
    */
-  public static priceControllerUpdate(
-    data: PriceControllerUpdateData
-  ): CancelablePromise<PriceControllerUpdateResponse> {
+  public static payeeControllerGetTopPayees(
+    data: PayeeControllerGetTopPayeesData = {}
+  ): CancelablePromise<PayeeControllerGetTopPayeesResponse> {
     return __request(OpenAPI, {
-      method: 'PUT',
-      url: '/api/v1/{region}/bean/prices/{id}',
-      path: {
-        id: data.id,
-        region: data.region
-      },
-      body: data.requestBody,
-      mediaType: 'application/json',
-      errors: {
-        404: 'Price not found',
-        409: 'Updated price conflicts with existing price'
+      method: 'GET',
+      url: '/api/v1/bean/payees/top',
+      query: {
+        limit: data.limit
       }
     });
   }
 
   /**
-   * Delete a price
-   * Deletes a price entry (hard delete)
+   * Get payee by ID
+   * Returns a specific payee mapping by its UUID
    * @param data The data for the request.
-   * @param data.id Price ID
-   * @param data.region Region code for tenant context
-   * @returns void Price deleted successfully
+   * @param data.id Payee UUID
+   * @returns PayeeResponseDto Payee retrieved successfully
    * @throws ApiError
    */
-  public static priceControllerDelete(
-    data: PriceControllerDeleteData
-  ): CancelablePromise<PriceControllerDeleteResponse> {
+  public static payeeControllerFindOne(
+    data: PayeeControllerFindOneData
+  ): CancelablePromise<PayeeControllerFindOneResponse> {
     return __request(OpenAPI, {
-      method: 'DELETE',
-      url: '/api/v1/{region}/bean/prices/{id}',
+      method: 'GET',
+      url: '/api/v1/bean/payees/{id}',
       path: {
-        id: data.id,
-        region: data.region
+        id: data.id
       },
       errors: {
-        404: 'Price not found'
+        403: 'Payee belongs to another user',
+        404: 'Payee not found'
       }
     });
   }
 
   /**
-   * Bulk create prices
-   * Creates multiple price entries at once (skips duplicates)
+   * 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 for tenant context
+   * @param data.id Payee UUID
    * @param data.requestBody
-   * @returns PriceResponseDto Prices created successfully
+   * @returns PayeeResponseDto Payee updated successfully
    * @throws ApiError
    */
-  public static priceControllerBulkCreate(
-    data: PriceControllerBulkCreateData
-  ): CancelablePromise<PriceControllerBulkCreateResponse> {
+  public static payeeControllerUpdate(
+    data: PayeeControllerUpdateData
+  ): CancelablePromise<PayeeControllerUpdateResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/{region}/bean/prices/bulk',
+      method: 'PUT',
+      url: '/api/v1/bean/payees/{id}',
       path: {
-        region: data.region
+        id: data.id
       },
       body: data.requestBody,
-      mediaType: 'application/json'
+      mediaType: 'application/json',
+      errors: {
+        400: 'Invalid input data',
+        404: 'Payee not found'
+      }
     });
   }
-}
 
-export class RecurringRulesService {
   /**
-   * Create a new recurring rule
-   * Creates a new recurring transaction rule for the authenticated user
+   * 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 for tenant context
-   * @param data.requestBody
-   * @returns RecurringRuleResponseDto Rule created successfully
+   * @param data.id Payee UUID
+   * @returns void Payee deleted successfully
    * @throws ApiError
    */
-  public static recurringRuleControllerCreate(
-    data: RecurringRuleControllerCreateData
-  ): CancelablePromise<RecurringRuleControllerCreateResponse> {
+  public static payeeControllerDelete(
+    data: PayeeControllerDeleteData
+  ): CancelablePromise<PayeeControllerDeleteResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/{region}/bean/recurring-rules',
+      method: 'DELETE',
+      url: '/api/v1/bean/payees/{id}',
       path: {
-        region: data.region
+        id: data.id
       },
-      body: data.requestBody,
-      mediaType: 'application/json',
       errors: {
-        400: 'Invalid input data (e.g., autoCreate without accounts)',
-        409: 'Rule with same name already exists'
+        404: 'Payee not found'
       }
     });
   }
+}
 
+export class AdminPayeeProfilesService {
   /**
-   * List recurring rules
-   * Returns all recurring rules for the authenticated user with optional filtering
+   * 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 for tenant context
-   * @param data.isActive Filter by active status
-   * @param data.frequency Filter by frequency (WEEKLY, MONTHLY, etc.)
-   * @param data.hasAutoCreate Filter by autoCreate enabled
-   * @returns RecurringRuleResponseDto Rules retrieved successfully
+   * @param data.requestBody
+   * @returns PayeeProfileResponseDto Payee profile created successfully
    * @throws ApiError
    */
-  public static recurringRuleControllerFindAll(
-    data: RecurringRuleControllerFindAllData
-  ): CancelablePromise<RecurringRuleControllerFindAllResponse> {
+  public static payeeProfileAdminControllerCreate(
+    data: PayeeProfileAdminControllerCreateData
+  ): CancelablePromise<PayeeProfileAdminControllerCreateResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/{region}/bean/recurring-rules',
-      path: {
-        region: data.region
-      },
-      query: {
-        isActive: data.isActive,
-        frequency: data.frequency,
-        hasAutoCreate: data.hasAutoCreate
+      method: 'POST',
+      url: '/api/v1/admin/payee-profiles',
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: 'Validation failed',
+        403: 'Admin access required',
+        409: 'Payee profile already exists'
       }
     });
   }
 
   /**
-   * Create recurring rule from transaction
-   * Auto-creates a recurring rule using transaction data. User only confirms frequency.
+   * 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.transactionId Source transaction ID
-   * @param data.region Region code for tenant context
-   * @param data.requestBody
-   * @returns RecurringRuleResponseDto Rule created successfully
+   * @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)
+   * @param data.isActive Filter by active status (default: true - show only active)
+   * @param data.verified Filter by verification status. true = verified only, false = unverified only
+   * @param data.dataSource Filter by data source
+   * @returns PayeeProfileListResponseDto Payee profiles retrieved successfully
    * @throws ApiError
    */
-  public static recurringRuleControllerCreateFromTransaction(
-    data: RecurringRuleControllerCreateFromTransactionData
-  ): CancelablePromise<RecurringRuleControllerCreateFromTransactionResponse> {
+  public static payeeProfileAdminControllerFindAll(
+    data: PayeeProfileAdminControllerFindAllData = {}
+  ): CancelablePromise<PayeeProfileAdminControllerFindAllResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/{region}/bean/recurring-rules/from-transaction/{transactionId}',
-      path: {
-        transactionId: data.transactionId,
-        region: data.region
+      method: 'GET',
+      url: '/api/v1/admin/payee-profiles',
+      query: {
+        search: data.search,
+        category: data.category,
+        country: data.country,
+        isActive: data.isActive,
+        verified: data.verified,
+        dataSource: data.dataSource
       },
-      body: data.requestBody,
-      mediaType: 'application/json',
       errors: {
-        404: 'Transaction not found',
-        409: 'Rule with same name already exists or transaction already linked'
+        403: 'Admin access required'
       }
     });
   }
 
   /**
-   * Get recurring rule by ID
-   * Returns a specific recurring rule with its details
+   * Get payee profile by ID (Admin only)
+   * Returns a single payee profile by its ID.
    * @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
+   * @param data.id Payee profile ID (UUID)
+   * @returns PayeeProfileResponseDto Payee profile retrieved successfully
    * @throws ApiError
    */
-  public static recurringRuleControllerFindOne(
-    data: RecurringRuleControllerFindOneData
-  ): CancelablePromise<RecurringRuleControllerFindOneResponse> {
+  public static payeeProfileAdminControllerFindOne(
+    data: PayeeProfileAdminControllerFindOneData
+  ): CancelablePromise<PayeeProfileAdminControllerFindOneResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/{region}/bean/recurring-rules/{id}',
+      url: '/api/v1/admin/payee-profiles/{id}',
       path: {
-        id: data.id,
-        region: data.region
+        id: data.id
       },
       errors: {
-        404: 'Rule not found'
+        403: 'Admin access required',
+        404: 'Payee profile not found'
       }
     });
   }
 
   /**
-   * Update recurring rule
-   * Updates an existing recurring rule
+   * 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.id Rule ID
-   * @param data.region Region code for tenant context
+   * @param data.id Payee profile ID (UUID)
    * @param data.requestBody
-   * @returns RecurringRuleResponseDto Rule updated successfully
+   * @returns PayeeProfileResponseDto Payee profile updated successfully
    * @throws ApiError
    */
-  public static recurringRuleControllerUpdate(
-    data: RecurringRuleControllerUpdateData
-  ): CancelablePromise<RecurringRuleControllerUpdateResponse> {
+  public static payeeProfileAdminControllerUpdate(
+    data: PayeeProfileAdminControllerUpdateData
+  ): CancelablePromise<PayeeProfileAdminControllerUpdateResponse> {
     return __request(OpenAPI, {
-      method: 'PATCH',
-      url: '/api/v1/{region}/bean/recurring-rules/{id}',
+      method: 'PUT',
+      url: '/api/v1/admin/payee-profiles/{id}',
       path: {
-        id: data.id,
-        region: data.region
+        id: data.id
       },
       body: data.requestBody,
       mediaType: 'application/json',
       errors: {
-        400: 'Invalid input data',
-        404: 'Rule not found'
+        403: 'Admin access required',
+        404: 'Payee profile not found'
       }
     });
   }
 
   /**
-   * Delete recurring rule
-   * Soft deletes a recurring rule (sets isActive to false)
+   * 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.id Rule ID
-   * @param data.region Region code for tenant context
-   * @returns void Rule deleted successfully
+   * @param data.id Payee profile ID (UUID)
+   * @returns void Payee profile deleted successfully
    * @throws ApiError
    */
-  public static recurringRuleControllerDelete(
-    data: RecurringRuleControllerDeleteData
-  ): CancelablePromise<RecurringRuleControllerDeleteResponse> {
+  public static payeeProfileAdminControllerDelete(
+    data: PayeeProfileAdminControllerDeleteData
+  ): CancelablePromise<PayeeProfileAdminControllerDeleteResponse> {
     return __request(OpenAPI, {
       method: 'DELETE',
-      url: '/api/v1/{region}/bean/recurring-rules/{id}',
+      url: '/api/v1/admin/payee-profiles/{id}',
       path: {
-        id: data.id,
-        region: data.region
+        id: data.id
       },
       errors: {
-        404: 'Rule not found'
+        403: 'Admin access required',
+        404: 'Payee profile not found',
+        409: 'Payee profile is in use and cannot be deleted'
       }
     });
   }
 
   /**
-   * Get rule with statistics
-   * Returns a rule with pending/overdue counts and next expected date
+   * 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.id Rule ID
-   * @param data.region Region code for tenant context
-   * @returns RecurringRuleWithStatsResponseDto Rule with stats retrieved successfully
+   * @param data.id Payee profile ID (UUID)
+   * @returns PayeeProfileResponseDto Payee profile verified successfully
    * @throws ApiError
    */
-  public static recurringRuleControllerGetWithStats(
-    data: RecurringRuleControllerGetWithStatsData
-  ): CancelablePromise<RecurringRuleControllerGetWithStatsResponse> {
+  public static payeeProfileAdminControllerVerify(
+    data: PayeeProfileAdminControllerVerifyData
+  ): CancelablePromise<PayeeProfileAdminControllerVerifyResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/{region}/bean/recurring-rules/{id}/stats',
+      method: 'POST',
+      url: '/api/v1/admin/payee-profiles/{id}/verify',
       path: {
-        id: data.id,
-        region: data.region
+        id: data.id
       },
       errors: {
-        404: 'Rule not found'
+        403: 'Admin access required',
+        404: 'Payee profile not found'
       }
     });
   }
-}
 
-export class ExpectedTransactionsService {
   /**
-   * List expected transactions
-   * Returns expected transactions for the authenticated user with optional filtering
+   * 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 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
+   * @param data.id Payee profile ID (UUID)
+   * @returns void Payee profile unverified successfully
    * @throws ApiError
    */
-  public static expectedTransactionControllerFindAll(
-    data: ExpectedTransactionControllerFindAllData
-  ): CancelablePromise<ExpectedTransactionControllerFindAllResponse> {
+  public static payeeProfileAdminControllerUnverify(
+    data: PayeeProfileAdminControllerUnverifyData
+  ): CancelablePromise<PayeeProfileAdminControllerUnverifyResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/{region}/bean/expected-transactions',
+      method: 'DELETE',
+      url: '/api/v1/admin/payee-profiles/{id}/verify',
       path: {
-        region: data.region
+        id: data.id
       },
-      query: {
-        ruleId: data.ruleId,
-        status: data.status,
-        fromDate: data.fromDate,
-        toDate: data.toDate
+      errors: {
+        403: 'Admin access required',
+        404: 'Payee profile not found'
       }
     });
   }
+}
 
+export class PayeeProfilesService {
   /**
-   * 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
+   * List active payee profiles (directory dump)
+   * Returns the full active PayeeProfile set as a trimmed projection for client-side dictionary caching. Aliases are verbatim as stored; clients normalize on their side.
+   * @returns PayeeProfileDirectoryResponseDto Active payee profiles
    * @throws ApiError
    */
-  public static expectedTransactionControllerFindOverdue(
-    data: ExpectedTransactionControllerFindOverdueData
-  ): CancelablePromise<ExpectedTransactionControllerFindOverdueResponse> {
+  public static payeeProfileControllerListActive(): CancelablePromise<PayeeProfileControllerListActiveResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/{region}/bean/expected-transactions/overdue',
-      path: {
-        region: data.region
+      url: '/api/v1/bean/payee-profiles',
+      errors: {
+        401: 'Missing or invalid token'
       }
     });
   }
+}
 
+export class BeanCommoditiesService {
   /**
-   * Get expected transaction by ID
-   * Returns a specific expected transaction with rule details
+   * Create a new commodity
+   * Creates a new commodity definition for the authenticated user
    * @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
+   * @param data.requestBody
+   * @returns CommodityResponseDto Commodity created successfully
    * @throws ApiError
    */
-  public static expectedTransactionControllerFindOne(
-    data: ExpectedTransactionControllerFindOneData
-  ): CancelablePromise<ExpectedTransactionControllerFindOneResponse> {
+  public static commodityControllerCreate(
+    data: CommodityControllerCreateData
+  ): CancelablePromise<CommodityControllerCreateResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/{region}/bean/expected-transactions/{id}',
+      method: 'POST',
+      url: '/api/v1/{region}/bean/commodities',
       path: {
-        id: data.id,
         region: data.region
       },
+      body: data.requestBody,
+      mediaType: 'application/json',
       errors: {
-        404: 'Expected transaction not found'
+        400: 'Invalid input data',
+        409: 'Commodity already exists'
       }
     });
   }
 
   /**
-   * Skip expected transaction
-   * Marks an expected transaction as skipped (PENDING -> SKIPPED)
+   * List user commodities
+   * Returns all commodity definitions for the authenticated user with optional filtering
    * @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
+   * @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
    * @throws ApiError
    */
-  public static expectedTransactionControllerSkip(
-    data: ExpectedTransactionControllerSkipData
-  ): CancelablePromise<ExpectedTransactionControllerSkipResponse> {
+  public static commodityControllerFindAll(
+    data: CommodityControllerFindAllData
+  ): CancelablePromise<CommodityControllerFindAllResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/{region}/bean/expected-transactions/{id}/skip',
+      method: 'GET',
+      url: '/api/v1/{region}/bean/commodities',
       path: {
-        id: data.id,
         region: data.region
       },
-      errors: {
-        400: 'Cannot skip - not in PENDING status',
-        404: 'Expected transaction not found'
+      query: {
+        search: data.search,
+        symbol: data.symbol
       }
     });
   }
 
   /**
-   * Undo skip
-   * Reverses a skip operation (SKIPPED -> PENDING)
+   * Get commodity by symbol
+   * Returns a specific commodity definition by its symbol
    * @param data The data for the request.
-   * @param data.id Expected transaction ID
+   * @param data.symbol Commodity symbol
    * @param data.region Region code for tenant context
-   * @returns ExpectedTransactionResponseDto Skip undone successfully
+   * @returns CommodityResponseDto Commodity retrieved successfully
    * @throws ApiError
    */
-  public static expectedTransactionControllerUndoSkip(
-    data: ExpectedTransactionControllerUndoSkipData
-  ): CancelablePromise<ExpectedTransactionControllerUndoSkipResponse> {
+  public static commodityControllerFindOne(
+    data: CommodityControllerFindOneData
+  ): CancelablePromise<CommodityControllerFindOneResponse> {
     return __request(OpenAPI, {
-      method: 'DELETE',
-      url: '/api/v1/{region}/bean/expected-transactions/{id}/skip',
+      method: 'GET',
+      url: '/api/v1/{region}/bean/commodities/{symbol}',
       path: {
-        id: data.id,
+        symbol: data.symbol,
         region: data.region
       },
       errors: {
-        400: 'Cannot undo - not in SKIPPED status',
-        404: 'Expected transaction not found'
+        404: 'Commodity not found'
       }
     });
   }
 
   /**
-   * Confirm transaction match
-   * Manually matches an expected transaction with an actual transaction
+   * Update commodity
+   * Updates an existing commodity definition. Symbol cannot be changed.
    * @param data The data for the request.
-   * @param data.id Expected transaction ID
+   * @param data.symbol Commodity symbol
    * @param data.region Region code for tenant context
    * @param data.requestBody
-   * @returns unknown Match confirmed successfully
+   * @returns CommodityResponseDto Commodity updated successfully
    * @throws ApiError
    */
-  public static expectedTransactionControllerConfirmMatch(
-    data: ExpectedTransactionControllerConfirmMatchData
-  ): CancelablePromise<ExpectedTransactionControllerConfirmMatchResponse> {
+  public static commodityControllerUpdate(
+    data: CommodityControllerUpdateData
+  ): CancelablePromise<CommodityControllerUpdateResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/{region}/bean/expected-transactions/{id}/match',
+      method: 'PUT',
+      url: '/api/v1/{region}/bean/commodities/{symbol}',
       path: {
-        id: data.id,
+        symbol: data.symbol,
         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'
+        400: 'Invalid input data',
+        404: 'Commodity not found'
       }
     });
   }
 
   /**
-   * Unmatch transaction
-   * Removes the match between expected and actual transaction (COMPLETED -> PENDING)
+   * Delete commodity
+   * Deletes a commodity definition
    * @param data The data for the request.
-   * @param data.id Expected transaction ID
+   * @param data.symbol Commodity symbol
    * @param data.region Region code for tenant context
-   * @returns unknown Match removed successfully
+   * @returns void Commodity deleted successfully
    * @throws ApiError
    */
-  public static expectedTransactionControllerUnmatch(
-    data: ExpectedTransactionControllerUnmatchData
-  ): CancelablePromise<ExpectedTransactionControllerUnmatchResponse> {
+  public static commodityControllerDelete(
+    data: CommodityControllerDeleteData
+  ): CancelablePromise<CommodityControllerDeleteResponse> {
     return __request(OpenAPI, {
       method: 'DELETE',
-      url: '/api/v1/{region}/bean/expected-transactions/{id}/match',
+      url: '/api/v1/{region}/bean/commodities/{symbol}',
       path: {
-        id: data.id,
+        symbol: data.symbol,
         region: data.region
       },
       errors: {
-        400: 'Cannot unmatch - not in COMPLETED status',
-        404: 'Expected transaction not found'
+        404: 'Commodity not found'
       }
     });
   }
 
   /**
-   * Enter Now
-   * Creates an actual transaction for an expected transaction (YNAB-style Enter Now)
+   * Ensure commodity exists
+   * Gets existing commodity or creates it with automatic initialization from OpenBB
    * @param data The data for the request.
-   * @param data.id Expected transaction ID
+   * @param data.symbol Commodity symbol
    * @param data.region Region code for tenant context
-   * @param data.requestBody
-   * @returns unknown Transaction created successfully
+   * @returns CommodityResponseDto Commodity retrieved or created
    * @throws ApiError
    */
-  public static expectedTransactionControllerEnterNow(
-    data: ExpectedTransactionControllerEnterNowData
-  ): CancelablePromise<ExpectedTransactionControllerEnterNowResponse> {
+  public static commodityControllerGetOrCreate(
+    data: CommodityControllerGetOrCreateData
+  ): CancelablePromise<CommodityControllerGetOrCreateResponse> {
     return __request(OpenAPI, {
       method: 'POST',
-      url: '/api/v1/{region}/bean/expected-transactions/{id}/enter',
+      url: '/api/v1/{region}/bean/commodities/{symbol}/ensure',
       path: {
-        id: data.id,
+        symbol: data.symbol,
         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
+   * 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 for tenant context
-   * @param data.months Number of months to forecast (1-12, default 3)
-   * @returns ForecastResponseDto Forecast retrieved successfully
+   * @returns CommodityResponseDto Commodities created successfully
    * @throws ApiError
    */
-  public static forecastControllerGetForecast(
-    data: ForecastControllerGetForecastData
-  ): CancelablePromise<ForecastControllerGetForecastResponse> {
+  public static commodityControllerBulkCreate(
+    data: CommodityControllerBulkCreateData
+  ): CancelablePromise<CommodityControllerBulkCreateResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/{region}/bean/recurring/forecast',
+      method: 'POST',
+      url: '/api/v1/{region}/bean/commodities/bulk',
       path: {
         region: data.region
-      },
-      query: {
-        months: data.months
       }
     });
   }
@@ -2322,534 +2291,626 @@ export class ReportingService {
   }
 }
 
-export class UsersService {
+export class BeanPricesService {
   /**
-   * Delete own user account
+   * Create a new price
+   * Creates a new price entry for the authenticated user
    * @param data The data for the request.
+   * @param data.region Region code for tenant context
    * @param data.requestBody
-   * @returns void User deleted successfully
+   * @returns PriceResponseDto Price created successfully
    * @throws ApiError
    */
-  public static userControllerDeleteOwnUser(
-    data: UserControllerDeleteOwnUserData
-  ): CancelablePromise<UserControllerDeleteOwnUserResponse> {
+  public static priceControllerCreate(
+    data: PriceControllerCreateData
+  ): CancelablePromise<PriceControllerCreateResponse> {
     return __request(OpenAPI, {
-      method: 'DELETE',
-      url: '/api/v1/users',
+      method: 'POST',
+      url: '/api/v1/{region}/bean/prices',
+      path: {
+        region: data.region
+      },
       body: data.requestBody,
       mediaType: 'application/json',
       errors: {
-        403: 'Invalid access token'
+        404: 'Currency or quoteCurrency commodity not found',
+        409: 'Price already exists for this currency pair and date'
       }
     });
   }
 
   /**
-   * Get current authenticated user
+   * List user prices
+   * Returns all price entries for the authenticated user with optional filtering
    * @param data The data for the request.
-   * @param data.acceptLanguage
-   * @returns unknown User 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 userControllerGetUser(
-    data: UserControllerGetUserData
-  ): CancelablePromise<UserControllerGetUserResponse> {
+  public static priceControllerFindAll(
+    data: PriceControllerFindAllData
+  ): CancelablePromise<PriceControllerFindAllResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/users',
-      headers: {
-        'accept-language': data.acceptLanguage
+      url: '/api/v1/{region}/bean/prices',
+      path: {
+        region: data.region
+      },
+      query: {
+        currency: data.currency,
+        quoteCurrency: data.quoteCurrency,
+        dateFrom: data.dateFrom,
+        dateTo: data.dateTo,
+        search: data.search,
+        page: data.page,
+        limit: data.limit
       }
     });
   }
 
   /**
-   * Sign up new user
-   * Create a new account with auto-generated access token. Protected by Cloudflare Turnstile to prevent automated signup (when enabled).
+   * Get price by ID
+   * Returns a single price entry by its ID
+   * @param data The data for the request.
+   * @param data.id Price ID
+   * @param data.region Region code for tenant context
+   * @returns PriceResponseDto Price retrieved successfully
+   * @throws ApiError
+   */
+  public static priceControllerFindOne(
+    data: PriceControllerFindOneData
+  ): CancelablePromise<PriceControllerFindOneResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/bean/prices/{id}',
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      errors: {
+        404: 'Price not found'
+      }
+    });
+  }
+
+  /**
+   * Update a price
+   * Updates an existing price entry
    * @param data The data for the request.
+   * @param data.id Price ID
+   * @param data.region Region code for tenant context
    * @param data.requestBody
-   * @returns SignupResponseDto User created successfully
+   * @returns PriceResponseDto Price updated successfully
    * @throws ApiError
    */
-  public static userControllerSignupUser(
-    data: UserControllerSignupUserData
-  ): CancelablePromise<UserControllerSignupUserResponse> {
+  public static priceControllerUpdate(
+    data: PriceControllerUpdateData
+  ): CancelablePromise<PriceControllerUpdateResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/users',
+      method: 'PUT',
+      url: '/api/v1/{region}/bean/prices/{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'
+        404: 'Price not found',
+        409: 'Updated price conflicts with existing price'
       }
     });
   }
 
   /**
-   * Delete user by ID (admin only)
+   * Delete a price
+   * Deletes a price entry (hard delete)
    * @param data The data for the request.
-   * @param data.id User ID to delete
-   * @returns void User deleted successfully
+   * @param data.id Price ID
+   * @param data.region Region code for tenant context
+   * @returns void Price deleted successfully
    * @throws ApiError
    */
-  public static userControllerDeleteUser(
-    data: UserControllerDeleteUserData
-  ): CancelablePromise<UserControllerDeleteUserResponse> {
+  public static priceControllerDelete(
+    data: PriceControllerDeleteData
+  ): CancelablePromise<PriceControllerDeleteResponse> {
     return __request(OpenAPI, {
       method: 'DELETE',
-      url: '/api/v1/users/{id}',
+      url: '/api/v1/{region}/bean/prices/{id}',
       path: {
-        id: data.id
+        id: data.id,
+        region: data.region
       },
       errors: {
-        403: 'Cannot delete own account or insufficient permissions'
+        404: 'Price not found'
       }
     });
   }
 
   /**
-   * Get user info by user ID
+   * Bulk create prices
+   * Creates multiple price entries at once (skips duplicates)
    * @param data The data for the request.
-   * @param data.id User ID
-   * @returns unknown User info retrieved successfully
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns PriceResponseDto Prices created successfully
    * @throws ApiError
    */
-  public static userControllerGetUserInfo(
-    data: UserControllerGetUserInfoData
-  ): CancelablePromise<UserControllerGetUserInfoResponse> {
+  public static priceControllerBulkCreate(
+    data: PriceControllerBulkCreateData
+  ): CancelablePromise<PriceControllerBulkCreateResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/users/{id}/info',
+      method: 'POST',
+      url: '/api/v1/{region}/bean/prices/bulk',
       path: {
-        id: data.id
+        region: data.region
       },
-      errors: {
-        403: 'Cannot access other user info without admin permission'
-      }
+      body: data.requestBody,
+      mediaType: 'application/json'
     });
   }
+}
 
+export class RecurringRulesService {
   /**
-   * Update user settings
+   * Create a new recurring rule
+   * Creates a new recurring transaction rule for the authenticated user
    * @param data The data for the request.
+   * @param data.region Region code for tenant context
    * @param data.requestBody
-   * @returns unknown Settings updated successfully
+   * @returns RecurringRuleResponseDto Rule created successfully
    * @throws ApiError
    */
-  public static userControllerUpdateUserSetting(
-    data: UserControllerUpdateUserSettingData
-  ): CancelablePromise<UserControllerUpdateUserSettingResponse> {
+  public static recurringRuleControllerCreate(
+    data: RecurringRuleControllerCreateData
+  ): CancelablePromise<RecurringRuleControllerCreateResponse> {
     return __request(OpenAPI, {
-      method: 'PUT',
-      url: '/api/v1/users/setting',
+      method: 'POST',
+      url: '/api/v1/{region}/bean/recurring-rules',
+      path: {
+        region: data.region
+      },
       body: data.requestBody,
       mediaType: 'application/json',
       errors: {
-        403: 'Insufficient permissions'
+        400: 'Invalid input data (e.g., autoCreate without accounts)',
+        409: 'Rule with same name already exists'
       }
     });
   }
 
   /**
-   * Get all user settings paginated (admin only)
+   * List recurring rules
+   * Returns all recurring rules for the authenticated user with optional filtering
    * @param data The data for the request.
-   * @param data.pageNo Page number
-   * @param data.pageSize Page size
-   * @returns unknown Settings list retrieved successfully
+   * @param data.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 userControllerGetAllUserSettingsByPage(
-    data: UserControllerGetAllUserSettingsByPageData
-  ): CancelablePromise<UserControllerGetAllUserSettingsByPageResponse> {
+  public static recurringRuleControllerFindAll(
+    data: RecurringRuleControllerFindAllData
+  ): CancelablePromise<RecurringRuleControllerFindAllResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/users/settings-by-page',
+      url: '/api/v1/{region}/bean/recurring-rules',
+      path: {
+        region: data.region
+      },
       query: {
-        pageNo: data.pageNo,
-        pageSize: data.pageSize
+        isActive: data.isActive,
+        frequency: data.frequency,
+        hasAutoCreate: data.hasAutoCreate
       }
     });
   }
 
   /**
-   * Get asset and liability summary for current user
-   * @returns unknown Summary retrieved successfully
+   * 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 userControllerGetAssetLiabilitySummary(): CancelablePromise<UserControllerGetAssetLiabilitySummaryResponse> {
+  public static recurringRuleControllerCreateFromTransaction(
+    data: RecurringRuleControllerCreateFromTransactionData
+  ): CancelablePromise<RecurringRuleControllerCreateFromTransactionResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/users/asset-liability-summary'
+      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'
+      }
     });
   }
-}
 
-export class PropertiesService {
   /**
-   * Get all system properties
-   * @returns unknown Properties retrieved successfully
+   * 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 propertyControllerGetAll(): CancelablePromise<PropertyControllerGetAllResponse> {
+  public static recurringRuleControllerFindOne(
+    data: RecurringRuleControllerFindOneData
+  ): CancelablePromise<RecurringRuleControllerFindOneResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/admin/properties',
+      url: '/api/v1/{region}/bean/recurring-rules/{id}',
+      path: {
+        id: data.id,
+        region: data.region
+      },
       errors: {
-        401: 'Unauthorized',
-        403: 'Forbidden - insufficient permissions'
+        404: 'Rule not found'
       }
     });
   }
 
   /**
-   * Get property by key
+   * Update recurring rule
+   * Updates an existing recurring rule
    * @param data The data for the request.
-   * @param data.key Property key
-   * @returns unknown Property retrieved successfully
+   * @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 propertyControllerGetByKey(
-    data: PropertyControllerGetByKeyData
-  ): CancelablePromise<PropertyControllerGetByKeyResponse> {
+  public static recurringRuleControllerUpdate(
+    data: RecurringRuleControllerUpdateData
+  ): CancelablePromise<RecurringRuleControllerUpdateResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/admin/properties/{key}',
+      method: 'PATCH',
+      url: '/api/v1/{region}/bean/recurring-rules/{id}',
       path: {
-        key: data.key
+        id: data.id,
+        region: data.region
       },
+      body: data.requestBody,
+      mediaType: 'application/json',
       errors: {
-        401: 'Unauthorized',
-        403: 'Forbidden - insufficient permissions',
-        404: 'Property not found'
+        400: 'Invalid input data',
+        404: 'Rule not found'
       }
     });
   }
 
   /**
-   * Update a system property
+   * Delete recurring rule
+   * Soft deletes a recurring rule (sets isActive to false)
    * @param data The data for the request.
-   * @param data.key Property key
-   * @param data.requestBody
-   * @returns unknown Property updated successfully
+   * @param data.id Rule ID
+   * @param data.region Region code for tenant context
+   * @returns void Rule deleted successfully
    * @throws ApiError
    */
-  public static propertyControllerUpdate(
-    data: PropertyControllerUpdateData
-  ): CancelablePromise<PropertyControllerUpdateResponse> {
+  public static recurringRuleControllerDelete(
+    data: RecurringRuleControllerDeleteData
+  ): CancelablePromise<RecurringRuleControllerDeleteResponse> {
     return __request(OpenAPI, {
-      method: 'PUT',
-      url: '/api/v1/admin/properties/{key}',
+      method: 'DELETE',
+      url: '/api/v1/{region}/bean/recurring-rules/{id}',
       path: {
-        key: data.key
+        id: data.id,
+        region: data.region
       },
-      body: data.requestBody,
-      mediaType: 'application/json',
       errors: {
-        401: 'Unauthorized',
-        403: 'Forbidden - insufficient permissions'
+        404: 'Rule not found'
       }
     });
   }
 
   /**
-   * Delete a system property
+   * Get rule with statistics
+   * Returns a rule with pending/overdue counts and next expected date
    * @param data The data for the request.
-   * @param data.key Property key
-   * @returns void Property deleted successfully
+   * @param data.id Rule ID
+   * @param data.region Region code for tenant context
+   * @returns RecurringRuleWithStatsResponseDto Rule with stats retrieved successfully
    * @throws ApiError
    */
-  public static propertyControllerDelete(
-    data: PropertyControllerDeleteData
-  ): CancelablePromise<PropertyControllerDeleteResponse> {
+  public static recurringRuleControllerGetWithStats(
+    data: RecurringRuleControllerGetWithStatsData
+  ): CancelablePromise<RecurringRuleControllerGetWithStatsResponse> {
     return __request(OpenAPI, {
-      method: 'DELETE',
-      url: '/api/v1/admin/properties/{key}',
+      method: 'GET',
+      url: '/api/v1/{region}/bean/recurring-rules/{id}/stats',
       path: {
-        key: data.key
+        id: data.id,
+        region: data.region
       },
       errors: {
-        401: 'Unauthorized',
-        403: 'Forbidden - insufficient permissions',
-        404: 'Property not found'
+        404: 'Rule not found'
       }
     });
   }
 }
 
-export class BeanTransactionRulesService {
+export class ExpectedTransactionsService {
   /**
-   * 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.
+   * 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.requestBody
-   * @returns TransactionRuleResponseDto Rule updated successfully (upsert mode)
+   * @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 transactionRuleControllerCreate(
-    data: TransactionRuleControllerCreateData
-  ): CancelablePromise<TransactionRuleControllerCreateResponse> {
+  public static expectedTransactionControllerFindAll(
+    data: ExpectedTransactionControllerFindAllData
+  ): CancelablePromise<ExpectedTransactionControllerFindAllResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/{region}/bean/transaction-rules',
+      method: 'GET',
+      url: '/api/v1/{region}/bean/expected-transactions',
       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'
+      query: {
+        ruleId: data.ruleId,
+        status: data.status,
+        fromDate: data.fromDate,
+        toDate: data.toDate
       }
     });
   }
 
   /**
-   * Get all transaction rules for user
+   * 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
-   * @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
-   * @param data.learningSource Filter by learning source. Omit this parameter or pass empty string to get manually created rules (learningSource is null in database).
-   * @param data.autoApplyEnabled Filter by auto-apply status
-   * @returns TransactionRuleListResponseDto List of rules
+   * @returns ExpectedTransactionListResponseDto Overdue transactions retrieved successfully
    * @throws ApiError
    */
-  public static transactionRuleControllerList(
-    data: TransactionRuleControllerListData
-  ): CancelablePromise<TransactionRuleControllerListResponse> {
+  public static expectedTransactionControllerFindOverdue(
+    data: ExpectedTransactionControllerFindOverdueData
+  ): CancelablePromise<ExpectedTransactionControllerFindOverdueResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/{region}/bean/transaction-rules',
+      url: '/api/v1/{region}/bean/expected-transactions/overdue',
       path: {
         region: data.region
-      },
-      query: {
-        limit: data.limit,
-        offset: data.offset,
-        enabled: data.enabled,
-        learningSource: data.learningSource,
-        autoApplyEnabled: data.autoApplyEnabled
-      },
-      errors: {
-        401: 'Unauthorized'
       }
     });
   }
 
   /**
-   * Validate transaction rule configuration
+   * 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
-   * @param data.requestBody
-   * @returns ValidateRuleResponseDto Validation result
+   * @returns ExpectedTransactionResponseDto Expected transaction retrieved successfully
    * @throws ApiError
    */
-  public static transactionRuleControllerValidate(
-    data: TransactionRuleControllerValidateData
-  ): CancelablePromise<TransactionRuleControllerValidateResponse> {
+  public static expectedTransactionControllerFindOne(
+    data: ExpectedTransactionControllerFindOneData
+  ): CancelablePromise<ExpectedTransactionControllerFindOneResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/{region}/bean/transaction-rules/validate',
+      method: 'GET',
+      url: '/api/v1/{region}/bean/expected-transactions/{id}',
       path: {
+        id: data.id,
         region: data.region
       },
-      body: data.requestBody,
-      mediaType: 'application/json',
       errors: {
-        400: 'Validation failed',
-        401: 'Unauthorized'
+        404: 'Expected transaction not found'
       }
     });
   }
 
   /**
-   * Bulk create transaction rules
+   * 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
-   * @param data.requestBody
-   * @returns BulkCreateRulesResponseDto Bulk create completed
+   * @returns ExpectedTransactionResponseDto Expected transaction skipped successfully
    * @throws ApiError
    */
-  public static transactionRuleControllerBulkCreate(
-    data: TransactionRuleControllerBulkCreateData
-  ): CancelablePromise<TransactionRuleControllerBulkCreateResponse> {
+  public static expectedTransactionControllerSkip(
+    data: ExpectedTransactionControllerSkipData
+  ): CancelablePromise<ExpectedTransactionControllerSkipResponse> {
     return __request(OpenAPI, {
       method: 'POST',
-      url: '/api/v1/{region}/bean/transaction-rules/bulk',
+      url: '/api/v1/{region}/bean/expected-transactions/{id}/skip',
       path: {
+        id: data.id,
         region: data.region
       },
-      body: data.requestBody,
-      mediaType: 'application/json',
       errors: {
-        400: 'Invalid bulk create data',
-        401: 'Unauthorized'
+        400: 'Cannot skip - not in PENDING status',
+        404: 'Expected transaction not found'
       }
     });
   }
 
   /**
-   * Export transaction rules
+   * Undo skip
+   * Reverses a skip operation (SKIPPED -> PENDING)
    * @param data The data for the request.
-   * @param data.format Export format (currently only JSON supported)
+   * @param data.id Expected transaction ID
    * @param data.region Region code for tenant context
-   * @returns ExportRulesResponseDto Exported rules
+   * @returns void Skip undone successfully
    * @throws ApiError
    */
-  public static transactionRuleControllerExport(
-    data: TransactionRuleControllerExportData
-  ): CancelablePromise<TransactionRuleControllerExportResponse> {
+  public static expectedTransactionControllerUndoSkip(
+    data: ExpectedTransactionControllerUndoSkipData
+  ): CancelablePromise<ExpectedTransactionControllerUndoSkipResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/{region}/bean/transaction-rules/export/{format}',
+      method: 'DELETE',
+      url: '/api/v1/{region}/bean/expected-transactions/{id}/skip',
       path: {
-        format: data.format,
+        id: data.id,
         region: data.region
       },
       errors: {
-        400: 'Unsupported format',
-        401: 'Unauthorized'
+        400: 'Cannot undo - not in SKIPPED status',
+        404: 'Expected transaction not found'
       }
     });
   }
 
   /**
-   * Get transaction rule statistics
+   * Confirm transaction match
+   * Manually matches an expected transaction with an actual transaction
    * @param data The data for the request.
-   * @param data.period Statistics time period
+   * @param data.id Expected transaction ID
    * @param data.region Region code for tenant context
-   * @returns RuleStatisticsResponseDto Rule statistics
+   * @param data.requestBody
+   * @returns unknown Match confirmed successfully
    * @throws ApiError
    */
-  public static transactionRuleControllerGetStatistics(
-    data: TransactionRuleControllerGetStatisticsData
-  ): CancelablePromise<TransactionRuleControllerGetStatisticsResponse> {
+  public static expectedTransactionControllerConfirmMatch(
+    data: ExpectedTransactionControllerConfirmMatchData
+  ): CancelablePromise<ExpectedTransactionControllerConfirmMatchResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/{region}/bean/transaction-rules/statistics/{period}',
+      method: 'POST',
+      url: '/api/v1/{region}/bean/expected-transactions/{id}/match',
       path: {
-        period: data.period,
+        id: data.id,
         region: data.region
       },
+      body: data.requestBody,
+      mediaType: 'application/json',
       errors: {
-        401: 'Unauthorized'
+        400: 'Cannot match - not in PENDING status',
+        404: 'Expected or actual transaction not found',
+        409: 'Actual transaction already matched to another rule'
       }
     });
   }
 
   /**
-   * Get transaction rule detail
+   * Unmatch transaction
+   * Removes the match between expected and actual transaction (COMPLETED -> PENDING)
    * @param data The data for the request.
-   * @param data.ruleId Rule ID
+   * @param data.id Expected transaction ID
    * @param data.region Region code for tenant context
-   * @returns TransactionRuleResponseDto Rule details
+   * @returns void Match removed successfully
    * @throws ApiError
    */
-  public static transactionRuleControllerGetDetail(
-    data: TransactionRuleControllerGetDetailData
-  ): CancelablePromise<TransactionRuleControllerGetDetailResponse> {
+  public static expectedTransactionControllerUnmatch(
+    data: ExpectedTransactionControllerUnmatchData
+  ): CancelablePromise<ExpectedTransactionControllerUnmatchResponse> {
     return __request(OpenAPI, {
-      method: 'GET',
-      url: '/api/v1/{region}/bean/transaction-rules/{ruleId}',
+      method: 'DELETE',
+      url: '/api/v1/{region}/bean/expected-transactions/{id}/match',
       path: {
-        ruleId: data.ruleId,
+        id: data.id,
         region: data.region
       },
       errors: {
-        401: 'Unauthorized',
-        403: 'Forbidden - not owner of rule',
-        404: 'Rule not found'
+        400: 'Cannot unmatch - not in COMPLETED status',
+        404: 'Expected transaction not found'
       }
     });
   }
 
   /**
-   * Update a transaction rule
+   * Enter Now
+   * Creates an actual transaction for an expected transaction (YNAB-style Enter Now)
    * @param data The data for the request.
-   * @param data.ruleId Rule ID to update
+   * @param data.id Expected transaction ID
    * @param data.region Region code for tenant context
    * @param data.requestBody
-   * @returns TransactionRuleResponseDto Rule updated successfully
+   * @returns unknown Transaction created successfully
    * @throws ApiError
    */
-  public static transactionRuleControllerUpdate(
-    data: TransactionRuleControllerUpdateData
-  ): CancelablePromise<TransactionRuleControllerUpdateResponse> {
+  public static expectedTransactionControllerEnterNow(
+    data: ExpectedTransactionControllerEnterNowData
+  ): CancelablePromise<ExpectedTransactionControllerEnterNowResponse> {
     return __request(OpenAPI, {
-      method: 'PUT',
-      url: '/api/v1/{region}/bean/transaction-rules/{ruleId}',
+      method: 'POST',
+      url: '/api/v1/{region}/bean/expected-transactions/{id}/enter',
       path: {
-        ruleId: data.ruleId,
+        id: data.id,
         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'
+        400: 'Cannot enter - not in PENDING status or missing accounts',
+        404: 'Expected transaction or accounts not found'
       }
     });
   }
+}
 
+export class RecurringForecastService {
   /**
-   * Delete a transaction rule
+   * 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.ruleId Rule ID to delete
    * @param data.region Region code for tenant context
-   * @returns void Rule deleted successfully
+   * @param data.months Number of months to forecast (1-12, default 3)
+   * @returns ForecastResponseDto Forecast retrieved successfully
    * @throws ApiError
    */
-  public static transactionRuleControllerDelete(
-    data: TransactionRuleControllerDeleteData
-  ): CancelablePromise<TransactionRuleControllerDeleteResponse> {
+  public static forecastControllerGetForecast(
+    data: ForecastControllerGetForecastData
+  ): CancelablePromise<ForecastControllerGetForecastResponse> {
     return __request(OpenAPI, {
-      method: 'DELETE',
-      url: '/api/v1/{region}/bean/transaction-rules/{ruleId}',
+      method: 'GET',
+      url: '/api/v1/{region}/bean/recurring/forecast',
       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'
+      query: {
+        months: data.months
       }
     });
   }
+}
 
+export class BeanCategoryCatalogService {
   /**
-   * Test rule matching
+   * List category catalog for a region
+   * Returns the region-scoped category slugs (expense/income/investment/banking/transfer/payment) for the NLP result picker, each with the categoryAccount paths the region-enabled system rules map it to (#816). CN-exclusive payment instruments (huabei/baitiao) appear only under /cn.
    * @param data The data for the request.
-   * @param data.ruleId Rule ID to test
    * @param data.region Region code for tenant context
-   * @param data.requestBody
-   * @returns TestRuleResponseDto Test result
+   * @param data.scenario Filter by scenario
+   * @param data.routeBearing Filter by routeBearing (entity-router route() consumes it)
+   * @returns CategoryCatalogListResponseDto Category catalog retrieved successfully
    * @throws ApiError
    */
-  public static transactionRuleControllerTest(
-    data: TransactionRuleControllerTestData
-  ): CancelablePromise<TransactionRuleControllerTestResponse> {
+  public static categoryCatalogControllerList(
+    data: CategoryCatalogControllerListData
+  ): CancelablePromise<CategoryCatalogControllerListResponse> {
     return __request(OpenAPI, {
-      method: 'POST',
-      url: '/api/v1/{region}/bean/transaction-rules/{ruleId}/test',
+      method: 'GET',
+      url: '/api/v1/{region}/bean/categories',
       path: {
-        ruleId: data.ruleId,
         region: data.region
       },
-      body: data.requestBody,
-      mediaType: 'application/json',
-      errors: {
-        401: 'Unauthorized',
-        403: 'Forbidden - not owner of rule',
-        404: 'Rule not found'
+      query: {
+        scenario: data.scenario,
+        routeBearing: data.routeBearing
       }
     });
   }
@@ -3034,7 +3095,7 @@ export class OnboardingService {
   /**
    * Bootstrap core accounts + register asset accounts with opening balances (ADR-0113)
    * @param data The data for the request.
-   * @param data.region Region code for tenant context
+   * @param data.region Region code for tenant context. Not-yet-open codes are accepted: the universal catalog backs onboarding regardless of region (#759)
    * @param data.requestBody
    * @returns unknown Onboarding bootstrap result.
    * @throws ApiError
@@ -3167,13 +3228,20 @@ export class BeanExportService {
   /**
    * Export Beancount ledger as ZIP
    * Export all user Beancount data as a ZIP file containing ledger.beancount and yearly files in community format.
-   * @returns unknown
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @returns binary ZIP archive (application/zip) streamed as an attachment
    * @throws ApiError
    */
-  public static exportControllerExportBeancount(): CancelablePromise<ExportControllerExportBeancountResponse> {
+  public static exportControllerExportBeancount(
+    data: ExportControllerExportBeancountData
+  ): CancelablePromise<ExportControllerExportBeancountResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/{region}/bean/export/beancount'
+      url: '/api/v1/{region}/bean/export/beancount',
+      path: {
+        region: data.region
+      }
     });
   }
 }
@@ -3210,7 +3278,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.
+   * Server-side importer identification has been removed (ADR-0101); file matching is handled client-side via the community parser pipeline. Always returns identified=false with an explanatory message; kept for backward compatibility. Does not perform actual import.
    * @param data The data for the request.
    * @param data.region Region code for tenant context
    * @param data.formData File to identify
@@ -3730,13 +3798,20 @@ export class BeanPlatformsService {
 
   /**
    * Get platform list for current user
+   * @param data The data for the request.
+   * @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(): CancelablePromise<PlatformControllerGetPlatformListResponse> {
+  public static platformControllerGetPlatformList(
+    data: PlatformControllerGetPlatformListData = {}
+  ): CancelablePromise<PlatformControllerGetPlatformListResponse> {
     return __request(OpenAPI, {
       method: 'GET',
-      url: '/api/v1/bean/platforms/list'
+      url: '/api/v1/bean/platforms/list',
+      query: {
+        region: data.region
+      }
     });
   }
 
@@ -3744,7 +3819,7 @@ export class BeanPlatformsService {
    * Match platforms by name or alias
    * @param data The data for the request.
    * @param data.q Search query — Chinese name, English name, or abbreviation
-   * @param data.region Region code for category override lookup
+   * @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
    */
@@ -3761,6 +3836,31 @@ export class BeanPlatformsService {
     });
   }
 
+  /**
+   * Get the region and candidate account standards for a platform
+   * @param data The data for the request.
+   * @param data.id Platform ID (from a match result)
+   * @param data.region Region code (ISO 3166-1 alpha-2, case-insensitive). Required for global platforms (countryCode null) — resolved as their template region; ignored when the platform has its own countryCode.
+   * @param data.type Filter templates by account type (path first segment)
+   * @returns PlatformStandardsResponseDto Resolved region plus the merged account-standard catalog of that region (groupable by productCategory client-side)
+   * @throws ApiError
+   */
+  public static platformControllerGetPlatformStandards(
+    data: PlatformControllerGetPlatformStandardsData
+  ): CancelablePromise<PlatformControllerGetPlatformStandardsResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/bean/platforms/{id}/standards',
+      path: {
+        id: data.id
+      },
+      query: {
+        region: data.region,
+        type: data.type
+      }
+    });
+  }
+
   /**
    * Update a platform
    * @param data The data for the request.
@@ -3927,6 +4027,34 @@ export class DashboardService {
       }
     });
   }
+
+  /**
+   * Get the composite P8 advisor context
+   * Assembles the P8 data context in one call: net worth (verbatim GET /dashboard/net-worth shape, user base currency semantics per ADR-0070), trailing-12m flow totals over the 12 calendar months including the as-of month, and top-3 expense categories by account-path leaf key — both flow blocks priced in CNY per the P8 contract. The P8 snake_case field spellings (as_of, net_worth, trailing_12m) are mapped by the consumer; the wire keeps the family camelCase
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @param data.date As-of date for the snapshot and the trailing-12m window anchor (ISO 8601 format)
+   * @returns AdvisorContextResponseDto Advisor context retrieved successfully
+   * @throws ApiError
+   */
+  public static dashboardControllerGetAdvisorContext(
+    data: DashboardControllerGetAdvisorContextData
+  ): CancelablePromise<DashboardControllerGetAdvisorContextResponse> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/{region}/dashboard/advisor-context',
+      path: {
+        region: data.region
+      },
+      query: {
+        date: data.date
+      },
+      errors: {
+        400: 'Invalid date format',
+        401: 'User not authenticated, or the token is not advisor-scoped (exchange via POST /auth/sessions/advisor, #1512)'
+      }
+    });
+  }
 }
 
 export class InvestmentService {
@@ -4002,17 +4130,75 @@ export class AuthService {
       }
     });
   }
+
+  /**
+   * Exchange an access token for an advisor-scoped, short-TTL JWT (#1512)
+   * @param data The data for the request.
+   * @param data.requestBody
+   * @returns AdvisorLoginResponseDto Advisor-scope login successful — the token is valid only on advisor tool-face endpoints (e.g. GET /:region/dashboard/advisor-context)
+   * @throws ApiError
+   */
+  public static authControllerAdvisorTokenLogin(
+    data: AuthControllerAdvisorTokenLoginData
+  ): CancelablePromise<AuthControllerAdvisorTokenLoginResponse> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/auth/sessions/advisor',
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        401: 'Invalid access token'
+      }
+    });
+  }
+}
+
+export class CommunityService {
+  /**
+   * Relay a sanitized parser-contribution payload
+   * A server-side bot re-sanitizes the payload and opens an issue on the target repository; the issue URL is returned. The payload is never persisted or logged (forward-and-drop).
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context (routing only; the institution region rides in the payload meta)
+   * @param data.requestBody
+   * @returns ParserContributionRelayResponseDto Issue created by the bot
+   * @throws ApiError
+   */
+  public static parserContributionControllerCreate(
+    data: ParserContributionControllerCreateData
+  ): CancelablePromise<ParserContributionControllerCreateResponse> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/{region}/community/parser-contributions',
+      path: {
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: 'application/json',
+      errors: {
+        401: 'Unauthorized',
+        422: 'Validation failed (institution slug, empty samples, row/cell size limits)',
+        429: 'Rate limited (5 submissions per user per hour)',
+        501: 'Relay not configured on this deployment — clients fall back to the clipboard flow',
+        502: 'GitHub bot failure (upstream), safe to retry'
+      }
+    });
+  }
 }
 
-export class DefaultService {
+export class AdminCacheService {
   /**
-   * @returns unknown
+   * Flush entire cache (L1 + L2)
+   * Clears ALL cache entries across ALL namespaces and users. Use only for emergency cache corruption recovery, maintenance-window refresh, or development resets.
+   * @returns unknown Cache flushed successfully
    * @throws ApiError
    */
   public static cacheControllerFlushCache(): CancelablePromise<CacheControllerFlushCacheResponse> {
     return __request(OpenAPI, {
       method: 'POST',
-      url: '/api/v1/cache/flush'
+      url: '/api/v1/cache/flush',
+      errors: {
+        403: 'Admin access required'
+      }
     });
   }
 }
@@ -4181,7 +4367,7 @@ export class MarketDataService {
    * @param data The data for the request.
    * @param data.q Search term — matched against symbol and instrument name. Empty string returns [].
    * @param data.limit Maximum number of results (clamped 1..50)
-   * @param data.exchange Filter by exchange code (e.g. US, HK, SS, SZ)
+   * @param data.exchange Filter by exchange code (e.g. US, HK, SS, SZ). A-share codes also match symbol notations and venue-code aliases (exchange=SS matches SH/SHH column values and bare 6-digit Shanghai symbols; SZ likewise)
    * @param data.assetType Filter by OpenBB asset_type (e.g. stock, etf)
    * @returns SymbolSearchResultDto Ranked search results
    * @throws ApiError