@accounter/server 0.0.8-alpha-20251102200443-d7162b8ce1dfc629b8b454df17dcec9ed005a052 → 0.0.8-alpha-20251103003648-f6467c8cb9c739ec4439c260bccc7325f6a761ae

package/src/__generated__/types.ts

@@ -323,6 +323,19 @@ export type AuditOpinionType =
   /** Unqualified opinion with other emphases (בנוסח אחיד עם הפניות תשומת לב אחרת) */
   | 'UNQUALIFIED_WITH_OTHER_EMPHASES';
 
+/**  Result of the auto-match operation  */
+export type AutoMatchChargesResult = {
+  readonly __typename?: 'AutoMatchChargesResult';
+  /**  Array of error messages encountered during the operation  */
+  readonly errors: ReadonlyArray<Scalars['String']['output']>;
+  /**  Array of charges that were merged, with their confidence scores  */
+  readonly mergedCharges: ReadonlyArray<MergedCharge>;
+  /**  Array of charge UUIDs that had multiple high-confidence matches and were skipped  */
+  readonly skippedCharges: ReadonlyArray<Scalars['UUID']['output']>;
+  /**  Total number of charges that were successfully matched and merged  */
+  readonly totalMatches: Scalars['Int']['output'];
+};
+
 /**  transactions for balance report  */
 export type BalanceTransactions = {
   readonly __typename?: 'BalanceTransactions';
@@ -860,6 +873,22 @@ export type ChargeFilterType =
   | 'EXPENSE'
   | 'INCOME';
 
+/**  A single charge match with its confidence score  */
+export type ChargeMatch = {
+  readonly __typename?: 'ChargeMatch';
+  /**  UUID of the matched charge  */
+  readonly chargeId: Scalars['UUID']['output'];
+  /**  Confidence score between 0.00 and 1.00  */
+  readonly confidenceScore: Scalars['Float']['output'];
+};
+
+/**  Result of finding matches for a single charge  */
+export type ChargeMatchesResult = {
+  readonly __typename?: 'ChargeMatchesResult';
+  /**  Array of up to 5 matches, ordered by confidence score (highest first)  */
+  readonly matches: ReadonlyArray<ChargeMatch>;
+};
+
 /**  represent charge's metadata */
 export type ChargeMetadata = {
   readonly __typename?: 'ChargeMetadata';
@@ -2549,6 +2578,15 @@ export type MergeChargesByTransactionReferenceResult = {
   readonly success: Scalars['Boolean']['output'];
 };
 
+/**  A charge that was successfully merged during auto-match  */
+export type MergedCharge = {
+  readonly __typename?: 'MergedCharge';
+  /**  UUID of the deleted/merged-away charge  */
+  readonly chargeId: Scalars['UUID']['output'];
+  /**  Confidence score that triggered the merge  */
+  readonly confidenceScore: Scalars['Float']['output'];
+};
+
 /**  a misc expense   */
 export type MiscExpense = {
   readonly __typename?: 'MiscExpense';
@@ -2609,6 +2647,8 @@ export type Mutation = {
   readonly addDeelContract: Scalars['Boolean']['output'];
   readonly addSortCode: Scalars['Boolean']['output'];
   readonly addTag: Scalars['Boolean']['output'];
+  /**  Automatically match all unmatched charges above the confidence threshold  */
+  readonly autoMatchCharges: AutoMatchChargesResult;
   readonly batchGenerateBusinessesOutOfTransactions: ReadonlyArray<Business>;
   readonly batchUpdateCharges: BatchUpdateChargesResult;
   readonly batchUploadDocuments: ReadonlyArray<UploadDocumentResult>;
@@ -3570,6 +3610,8 @@ export type Query = {
   /**  get exchage rates by date  */
   readonly exchangeRates?: Maybe<ExchangeRates>;
   readonly financialEntity: FinancialEntity;
+  /**  Find potential matches for a single unmatched charge  */
+  readonly findChargeMatches: ChargeMatchesResult;
   readonly gmailListenerStatus: Scalars['Boolean']['output'];
   readonly greenInvoiceClient: GreenInvoiceClient;
   readonly incomeExpenseChart: IncomeExpenseChart;
@@ -3816,6 +3858,12 @@ export type QueryFinancialEntityArgs = {
 };
 
 
+/**  query root  */
+export type QueryFindChargeMatchesArgs = {
+  chargeId: Scalars['UUID']['input'];
+};
+
+
 /**  query root  */
 export type QueryGreenInvoiceClientArgs = {
   clientId: Scalars['UUID']['input'];
@@ -5060,6 +5108,7 @@ export type ResolversTypes = {
   AnnualId: ResolverTypeWrapper<AnnualId>;
   AnnualIdInput: AnnualIdInput;
   AuditOpinionType: AuditOpinionType;
+  AutoMatchChargesResult: ResolverTypeWrapper<AutoMatchChargesResult>;
   BalanceTransactions: ResolverTypeWrapper<IGetNormalizedBalanceTransactionsResult>;
   BankDeposit: ResolverTypeWrapper<Omit<BankDeposit, 'transactions'> & { transactions: ReadonlyArray<ResolversTypes['Transaction']> }>;
   BankDepositCharge: ResolverTypeWrapper<IGetChargesByIdsResult>;
@@ -5099,6 +5148,8 @@ export type ResolversTypes = {
   Charge: ResolverTypeWrapper<ResolversInterfaceTypes<ResolversTypes>['Charge']>;
   ChargeFilter: ChargeFilter;
   ChargeFilterType: ChargeFilterType;
+  ChargeMatch: ResolverTypeWrapper<ChargeMatch>;
+  ChargeMatchesResult: ResolverTypeWrapper<ChargeMatchesResult>;
   ChargeMetadata: ResolverTypeWrapper<IGetChargesByIdsResult>;
   ChargeSortBy: ChargeSortBy;
   ChargeSortByField: ChargeSortByField;
@@ -5226,6 +5277,7 @@ export type ResolversTypes = {
   MergeChargeResult: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['MergeChargeResult']>;
   MergeChargeSuccessfulResult: ResolverTypeWrapper<Omit<MergeChargeSuccessfulResult, 'charge'> & { charge: ResolversTypes['Charge'] }>;
   MergeChargesByTransactionReferenceResult: ResolverTypeWrapper<Omit<MergeChargesByTransactionReferenceResult, 'charges'> & { charges?: Maybe<ReadonlyArray<ResolversTypes['Charge']>> }>;
+  MergedCharge: ResolverTypeWrapper<MergedCharge>;
   MiscExpense: ResolverTypeWrapper<IGetExpensesByChargeIdsResult>;
   MissingChargeInfo: MissingChargeInfo;
   MonthlyVatCharge: ResolverTypeWrapper<IGetChargesByIdsResult>;
@@ -5350,6 +5402,7 @@ export type ResolversParentTypes = {
   AdminContextInput: AdminContextInput;
   AnnualId: AnnualId;
   AnnualIdInput: AnnualIdInput;
+  AutoMatchChargesResult: AutoMatchChargesResult;
   BalanceTransactions: IGetNormalizedBalanceTransactionsResult;
   BankDeposit: Omit<BankDeposit, 'transactions'> & { transactions: ReadonlyArray<ResolversParentTypes['Transaction']> };
   BankDepositCharge: IGetChargesByIdsResult;
@@ -5384,6 +5437,8 @@ export type ResolversParentTypes = {
   CategorizeIntoExistingBusinessTripExpenseInput: CategorizeIntoExistingBusinessTripExpenseInput;
   Charge: ResolversInterfaceTypes<ResolversParentTypes>['Charge'];
   ChargeFilter: ChargeFilter;
+  ChargeMatch: ChargeMatch;
+  ChargeMatchesResult: ChargeMatchesResult;
   ChargeMetadata: IGetChargesByIdsResult;
   ChargeSortBy: ChargeSortBy;
   ChargeSuggestions: Omit<ChargeSuggestions, 'tags'> & { tags: ReadonlyArray<ResolversParentTypes['Tag']> };
@@ -5488,6 +5543,7 @@ export type ResolversParentTypes = {
   MergeChargeResult: ResolversUnionTypes<ResolversParentTypes>['MergeChargeResult'];
   MergeChargeSuccessfulResult: Omit<MergeChargeSuccessfulResult, 'charge'> & { charge: ResolversParentTypes['Charge'] };
   MergeChargesByTransactionReferenceResult: Omit<MergeChargesByTransactionReferenceResult, 'charges'> & { charges?: Maybe<ReadonlyArray<ResolversParentTypes['Charge']>> };
+  MergedCharge: MergedCharge;
   MiscExpense: IGetExpensesByChargeIdsResult;
   MonthlyVatCharge: IGetChargesByIdsResult;
   Mutation: {};
@@ -5695,6 +5751,14 @@ export type AnnualIdResolvers<ContextType = GraphQLModules.Context, ParentType e
   __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 
+export type AutoMatchChargesResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['AutoMatchChargesResult'] = ResolversParentTypes['AutoMatchChargesResult']> = {
+  errors?: Resolver<ReadonlyArray<ResolversTypes['String']>, ParentType, ContextType>;
+  mergedCharges?: Resolver<ReadonlyArray<ResolversTypes['MergedCharge']>, ParentType, ContextType>;
+  skippedCharges?: Resolver<ReadonlyArray<ResolversTypes['UUID']>, ParentType, ContextType>;
+  totalMatches?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
 export type BalanceTransactionsResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BalanceTransactions'] = ResolversParentTypes['BalanceTransactions']> = {
   amount?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
   amountUsd?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
@@ -6043,6 +6107,17 @@ export type ChargeResolvers<ContextType = GraphQLModules.Context, ParentType ext
   yearsOfRelevance?: Resolver<Maybe<ReadonlyArray<ResolversTypes['YearOfRelevance']>>, ParentType, ContextType>;
 };
 
+export type ChargeMatchResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['ChargeMatch'] = ResolversParentTypes['ChargeMatch']> = {
+  chargeId?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
+  confidenceScore?: Resolver<ResolversTypes['Float'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type ChargeMatchesResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['ChargeMatchesResult'] = ResolversParentTypes['ChargeMatchesResult']> = {
+  matches?: Resolver<ReadonlyArray<ResolversTypes['ChargeMatch']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
 export type ChargeMetadataResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['ChargeMetadata'] = ResolversParentTypes['ChargeMetadata']> = {
   createdAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
   documentsCount?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
@@ -7000,6 +7075,12 @@ export type MergeChargesByTransactionReferenceResultResolvers<ContextType = Grap
   __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 
+export type MergedChargeResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['MergedCharge'] = ResolversParentTypes['MergedCharge']> = {
+  chargeId?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
+  confidenceScore?: Resolver<ResolversTypes['Float'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
 export type MiscExpenseResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['MiscExpense'] = ResolversParentTypes['MiscExpense']> = {
   amount?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
   charge?: Resolver<ResolversTypes['Charge'], ParentType, ContextType>;
@@ -7056,6 +7137,7 @@ export type MutationResolvers<ContextType = GraphQLModules.Context, ParentType e
   addDeelContract?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType, RequireFields<MutationAddDeelContractArgs, 'businessId' | 'contractId' | 'contractStartDate' | 'contractorId' | 'contractorName'>>;
   addSortCode?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType, RequireFields<MutationAddSortCodeArgs, 'key' | 'name'>>;
   addTag?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType, RequireFields<MutationAddTagArgs, 'name'>>;
+  autoMatchCharges?: Resolver<ResolversTypes['AutoMatchChargesResult'], ParentType, ContextType>;
   batchGenerateBusinessesOutOfTransactions?: Resolver<ReadonlyArray<ResolversTypes['Business']>, ParentType, ContextType>;
   batchUpdateCharges?: Resolver<ResolversTypes['BatchUpdateChargesResult'], ParentType, ContextType, RequireFields<MutationBatchUpdateChargesArgs, 'chargeIds' | 'fields'>>;
   batchUploadDocuments?: Resolver<ReadonlyArray<ResolversTypes['UploadDocumentResult']>, ParentType, ContextType, RequireFields<MutationBatchUploadDocumentsArgs, 'documents'>>;
@@ -7339,6 +7421,7 @@ export type QueryResolvers<ContextType = GraphQLModules.Context, ParentType exte
   employeesByEmployerId?: Resolver<ReadonlyArray<ResolversTypes['Employee']>, ParentType, ContextType, RequireFields<QueryEmployeesByEmployerIdArgs, 'employerId'>>;
   exchangeRates?: Resolver<Maybe<ResolversTypes['ExchangeRates']>, ParentType, ContextType, Partial<QueryExchangeRatesArgs>>;
   financialEntity?: Resolver<ResolversTypes['FinancialEntity'], ParentType, ContextType, RequireFields<QueryFinancialEntityArgs, 'id'>>;
+  findChargeMatches?: Resolver<ResolversTypes['ChargeMatchesResult'], ParentType, ContextType, RequireFields<QueryFindChargeMatchesArgs, 'chargeId'>>;
   gmailListenerStatus?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
   greenInvoiceClient?: Resolver<ResolversTypes['GreenInvoiceClient'], ParentType, ContextType, RequireFields<QueryGreenInvoiceClientArgs, 'clientId'>>;
   incomeExpenseChart?: Resolver<ResolversTypes['IncomeExpenseChart'], ParentType, ContextType, RequireFields<QueryIncomeExpenseChartArgs, 'filters'>>;
@@ -7880,6 +7963,7 @@ export type Resolvers<ContextType = GraphQLModules.Context> = {
   AdminBusiness?: AdminBusinessResolvers<ContextType>;
   AdminContext?: AdminContextResolvers<ContextType>;
   AnnualId?: AnnualIdResolvers<ContextType>;
+  AutoMatchChargesResult?: AutoMatchChargesResultResolvers<ContextType>;
   BalanceTransactions?: BalanceTransactionsResolvers<ContextType>;
   BankDeposit?: BankDepositResolvers<ContextType>;
   BankDepositCharge?: BankDepositChargeResolvers<ContextType>;
@@ -7907,6 +7991,8 @@ export type Resolvers<ContextType = GraphQLModules.Context> = {
   BusinessTripTravelAndSubsistenceExpense?: BusinessTripTravelAndSubsistenceExpenseResolvers<ContextType>;
   CardFinancialAccount?: CardFinancialAccountResolvers<ContextType>;
   Charge?: ChargeResolvers<ContextType>;
+  ChargeMatch?: ChargeMatchResolvers<ContextType>;
+  ChargeMatchesResult?: ChargeMatchesResultResolvers<ContextType>;
   ChargeMetadata?: ChargeMetadataResolvers<ContextType>;
   ChargeSortByField?: ChargeSortByFieldResolvers;
   ChargeSuggestions?: ChargeSuggestionsResolvers<ContextType>;
@@ -7989,6 +8075,7 @@ export type Resolvers<ContextType = GraphQLModules.Context> = {
   MergeChargeResult?: MergeChargeResultResolvers<ContextType>;
   MergeChargeSuccessfulResult?: MergeChargeSuccessfulResultResolvers<ContextType>;
   MergeChargesByTransactionReferenceResult?: MergeChargesByTransactionReferenceResultResolvers<ContextType>;
+  MergedCharge?: MergedChargeResolvers<ContextType>;
   MiscExpense?: MiscExpenseResolvers<ContextType>;
   MissingChargeInfo?: MissingChargeInfoResolvers;
   MonthlyVatCharge?: MonthlyVatChargeResolvers<ContextType>;

package/src/modules/charges-matcher/README.md

@@ -0,0 +1,279 @@
+# Charges Matcher Module
+
+This module implements a transaction-document matching system for the Accounter fullstack
+application. It provides both manual matching suggestions and automatic matching capabilities for
+unmatched charges.
+
+## Overview
+
+The charges-matcher module uses a confidence-based scoring algorithm to identify potential matches
+between:
+
+- Charges with only transactions (transaction charges)
+- Charges with only accounting documents (document charges)
+
+The system provides two main operations:
+
+1. **Single-Match Query**: Find potential matches for a specific unmatched charge
+2. **Auto-Match Mutation**: Automatically match all unmatched charges above a confidence threshold
+
+## Module Structure
+
+```
+charges-matcher/
+├── index.ts                          # Module exports and GraphQL module definition
+├── types.ts                          # TypeScript type definitions
+├── typeDefs/
+│   └── charges-matcher.graphql.ts    # GraphQL schema definitions
+├── resolvers/                        # GraphQL resolvers (to be implemented)
+├── providers/                        # Business logic providers (to be implemented)
+├── helpers/                          # Helper functions (to be implemented)
+└── __tests__/
+    ├── test-helpers.ts               # Test utilities and mock factories
+    └── test-infrastructure.spec.ts   # Infrastructure tests
+```
+
+## Type Definitions
+
+### Shared Types
+
+The module reuses types from existing modules:
+
+- `Transaction`: From `@modules/transactions/types.js` (`IGetTransactionsByIdsResult`)
+- `Document`: From `@modules/documents/types.js` (`IGetAllDocumentsResult`)
+- `Currency`: Re-exported from documents module
+- `DocumentType`: Re-exported from documents module
+
+### GraphQL Response Types
+
+- `ChargeMatch`: Single match with charge ID and confidence score
+- `ChargeMatchesResult`: Array of matches (up to 5)
+- `MergedCharge`: Record of a merged charge with confidence score
+- `AutoMatchChargesResult`: Summary of auto-match operation
+
+### Internal Types
+
+- `AggregatedTransaction`: Aggregated data from multiple transactions
+- `AggregatedDocument`: Aggregated data from multiple documents
+- `ConfidenceScores`: Individual confidence scores for each matching factor
+- `ConfidenceResult`: Complete confidence calculation result
+- `ChargeType`: Enum for charge classification (TRANSACTION_ONLY, DOCUMENT_ONLY, MATCHED)
+- `ChargeWithData`: Charge with its associated transactions and documents
+- `MatchCandidate`: Candidate charge with aggregated data
+
+## Database Schema
+
+The module works with these existing tables:
+
+### charges
+
+- `id`: UUID (primary key)
+- `owner_id`: UUID (references businesses)
+- Other fields not directly used in matching logic
+
+### transactions
+
+- `id`: UUID
+- `charge_id`: UUID (foreign key to charges)
+- `amount`: numeric (PostgreSQL numeric type)
+- `currency`: enum
+- `business_id`: UUID (nullable)
+- `event_date`: DATE
+- `debit_date`: DATE (nullable)
+- `debit_timestamp`: TIMESTAMP (nullable)
+- `is_fee`: boolean
+- `source_description`: text (nullable)
+
+### documents
+
+- `id`: UUID
+- `charge_id`: UUID (foreign key to charges)
+- `total_amount`: double precision (nullable)
+- `currency_code`: enum (nullable)
+- `creditor_id`: UUID (nullable)
+- `debtor_id`: UUID (nullable)
+- `date`: DATE (nullable)
+- `type`: enum (INVOICE, CREDIT_INVOICE, RECEIPT, etc.)
+- `serial_number`: text (nullable)
+
+## Testing Infrastructure
+
+### Mock Factories
+
+Test helpers provide factory functions for creating mock data:
+
+```typescript
+import {
+  createMockTransaction,
+  createMockDocument,
+  createMockAggregatedTransaction,
+  createMockAggregatedDocument,
+} from './__tests__/test-helpers.js';
+
+// Create a transaction with defaults
+const transaction = createMockTransaction();
+
+// Create with overrides
+const customTransaction = createMockTransaction({
+  amount: '250.00',
+  currency: 'USD',
+});
+```
+
+### Helper Functions
+
+```typescript
+import {
+  calculateExpectedConfidence,
+  roundConfidence,
+  isValidConfidenceScore,
+  daysDifference,
+  isWithinDays,
+} from './__tests__/test-helpers.js';
+
+// Calculate weighted confidence
+const scores = { amount: 0.9, currency: 1.0, business: 0.5, date: 0.8 };
+const confidence = calculateExpectedConfidence(scores); // 0.79
+
+// Round to 2 decimal places
+const rounded = roundConfidence(0.956789); // 0.96
+
+// Validate score range
+isValidConfidenceScore(0.95); // true
+isValidConfidenceScore(1.5); // false
+```
+
+## Key Concepts
+
+### Unmatched Charge
+
+A charge is considered unmatched if it has:
+
+- ≥1 transactions AND 0 accounting documents, OR
+- 0 transactions AND ≥1 accounting documents
+
+**Note**: PROFORMA, OTHER, and UNPROCESSED document types don't count toward matched/unmatched
+status.
+
+### Matched Charge
+
+A charge is considered matched if it has:
+
+- ≥1 transactions AND ≥1 accounting documents
+
+### Accounting Documents
+
+Documents with types: INVOICE, CREDIT_INVOICE, RECEIPT, INVOICE_RECEIPT
+
+### Confidence Score
+
+A value between 0.00 and 1.00 calculated using:
+
+```
+confidence = (amount × 0.4) + (currency × 0.2) + (business × 0.3) + (date × 0.1)
+```
+
+Where each component score is between 0.0 and 1.0.
+
+### Auto-Match Threshold
+
+Charges are automatically matched only when:
+
+- Exactly one match has confidence ≥ 0.95
+- Multiple matches ≥ 0.95 result in the charge being skipped
+
+## GraphQL API
+
+### Query: findChargeMatches
+
+Find potential matches for a single unmatched charge.
+
+```graphql
+query findChargeMatches($chargeId: UUID!) {
+  findChargeMatches(chargeId: $chargeId) {
+    matches {
+      chargeId
+      confidenceScore
+    }
+  }
+}
+```
+
+**Returns**: Up to 5 matches, ordered by confidence score (highest first)
+
+### Mutation: autoMatchCharges
+
+Automatically match all unmatched charges above the confidence threshold.
+
+```graphql
+mutation autoMatchCharges {
+  autoMatchCharges {
+    totalMatches
+    mergedCharges {
+      chargeId
+      confidenceScore
+    }
+    skippedCharges
+    errors
+  }
+}
+```
+
+**Returns**: Summary of matches made, skipped charges, and any errors
+
+## Implementation Roadmap
+
+### Step 1: Module Setup (✓ Complete)
+
+- [x] Create module structure
+- [x] Define TypeScript types
+- [x] Create GraphQL schema
+- [x] Set up test infrastructure
+
+### Step 2: Core Logic (To Do)
+
+- [ ] Implement charge classification
+- [ ] Implement multi-item aggregation
+- [ ] Implement confidence calculation helpers
+- [ ] Implement candidate filtering
+
+### Step 3: GraphQL Integration (To Do)
+
+- [ ] Implement findChargeMatches resolver
+- [ ] Implement autoMatchCharges resolver
+- [ ] Implement providers for data access
+- [ ] Add integration tests
+
+### Step 4: UI Integration (To Do)
+
+- [ ] Create ChargeMatchingModal component
+- [ ] Create AutoMatchButton component
+- [ ] Add to charge detail screens
+- [ ] Add to charges list view
+
+## Dependencies
+
+This module depends on:
+
+- `@modules/charges`: For charge data access and merge operations
+- `@modules/transactions`: For transaction data access
+- `@modules/documents`: For document data access
+- `@modules/common`: For error handling and common utilities
+- `@modules/financial-entities`: For business name resolution
+
+## Running Tests
+
+```bash
+# Run all tests
+yarn test
+
+# Run specific test file
+yarn test packages/server/src/modules/charges-matcher/__tests__/test-infrastructure.spec.ts
+
+# Run tests in watch mode
+yarn test --watch
+```
+
+## License
+
+See the main project LICENSE file.

package/src/modules/charges-matcher/__generated__/types.ts

@@ -0,0 +1,71 @@
+import * as Types from "../../../__generated__/types.js";
+import * as gm from "graphql-modules";
+export namespace ChargesMatcherModule {
+  interface DefinedFields {
+    Query: 'findChargeMatches';
+    Mutation: 'autoMatchCharges';
+    ChargeMatchesResult: 'matches';
+    ChargeMatch: 'chargeId' | 'confidenceScore';
+    AutoMatchChargesResult: 'totalMatches' | 'mergedCharges' | 'skippedCharges' | 'errors';
+    MergedCharge: 'chargeId' | 'confidenceScore';
+  };
+  
+  export type Query = Pick<Types.Query, DefinedFields['Query']>;
+  export type ChargeMatchesResult = Pick<Types.ChargeMatchesResult, DefinedFields['ChargeMatchesResult']>;
+  export type UUID = Types.Uuid;
+  export type Mutation = Pick<Types.Mutation, DefinedFields['Mutation']>;
+  export type AutoMatchChargesResult = Pick<Types.AutoMatchChargesResult, DefinedFields['AutoMatchChargesResult']>;
+  export type ChargeMatch = Pick<Types.ChargeMatch, DefinedFields['ChargeMatch']>;
+  export type MergedCharge = Pick<Types.MergedCharge, DefinedFields['MergedCharge']>;
+  
+  export type QueryResolvers = Pick<Types.QueryResolvers, DefinedFields['Query']>;
+  export type MutationResolvers = Pick<Types.MutationResolvers, DefinedFields['Mutation']>;
+  export type ChargeMatchesResultResolvers = Pick<Types.ChargeMatchesResultResolvers, DefinedFields['ChargeMatchesResult']>;
+  export type ChargeMatchResolvers = Pick<Types.ChargeMatchResolvers, DefinedFields['ChargeMatch']>;
+  export type AutoMatchChargesResultResolvers = Pick<Types.AutoMatchChargesResultResolvers, DefinedFields['AutoMatchChargesResult']>;
+  export type MergedChargeResolvers = Pick<Types.MergedChargeResolvers, DefinedFields['MergedCharge']>;
+  
+  export interface Resolvers {
+    Query?: QueryResolvers;
+    Mutation?: MutationResolvers;
+    ChargeMatchesResult?: ChargeMatchesResultResolvers;
+    ChargeMatch?: ChargeMatchResolvers;
+    AutoMatchChargesResult?: AutoMatchChargesResultResolvers;
+    MergedCharge?: MergedChargeResolvers;
+  };
+  
+  export interface MiddlewareMap {
+    '*'?: {
+      '*'?: gm.Middleware[];
+    };
+    Query?: {
+      '*'?: gm.Middleware[];
+      findChargeMatches?: gm.Middleware[];
+    };
+    Mutation?: {
+      '*'?: gm.Middleware[];
+      autoMatchCharges?: gm.Middleware[];
+    };
+    ChargeMatchesResult?: {
+      '*'?: gm.Middleware[];
+      matches?: gm.Middleware[];
+    };
+    ChargeMatch?: {
+      '*'?: gm.Middleware[];
+      chargeId?: gm.Middleware[];
+      confidenceScore?: gm.Middleware[];
+    };
+    AutoMatchChargesResult?: {
+      '*'?: gm.Middleware[];
+      totalMatches?: gm.Middleware[];
+      mergedCharges?: gm.Middleware[];
+      skippedCharges?: gm.Middleware[];
+      errors?: gm.Middleware[];
+    };
+    MergedCharge?: {
+      '*'?: gm.Middleware[];
+      chargeId?: gm.Middleware[];
+      confidenceScore?: gm.Middleware[];
+    };
+  };
+}