@accounter/server 0.0.8-alpha-20251102200443-d7162b8ce1dfc629b8b454df17dcec9ed005a052 → 0.0.8-alpha-20251102213150-c9d936f545d5351df0dc5326c2623266f1ad1f46

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # @accounter/server
 
-## 0.0.8-alpha-20251102200443-d7162b8ce1dfc629b8b454df17dcec9ed005a052
+## 0.0.8-alpha-20251102213150-c9d936f545d5351df0dc5326c2623266f1ad1f46
 
 ### Patch Changes
 
@@ -249,6 +249,21 @@
   - Updated dependency [`ai@5.0.82` ↗︎](https://www.npmjs.com/package/ai/v/5.0.82) (from `5.0.81`,
     in `dependencies`)
 
+- [#2647](https://github.com/Urigo/accounter-fullstack/pull/2647)
+  [`f171a4a`](https://github.com/Urigo/accounter-fullstack/commit/f171a4a83c5f30b0135c72991b4796677223ff39)
+  Thanks [@renovate](https://github.com/apps/renovate)! - dependencies updates:
+  - Updated dependency
+    [`@ai-sdk/anthropic@2.0.40` ↗︎](https://www.npmjs.com/package/@ai-sdk/anthropic/v/2.0.40) (from
+    `2.0.39`, in `dependencies`)
+  - Updated dependency [`ai@5.0.86` ↗︎](https://www.npmjs.com/package/ai/v/5.0.86) (from `5.0.82`,
+    in `dependencies`)
+
+- [#2654](https://github.com/Urigo/accounter-fullstack/pull/2654)
+  [`7fef068`](https://github.com/Urigo/accounter-fullstack/commit/7fef0682c7316153ae5ffde42f97ce7284dd4c9a)
+  Thanks [@renovate](https://github.com/apps/renovate)! - dependencies updates:
+  - Updated dependency [`graphql@16.12.0` ↗︎](https://www.npmjs.com/package/graphql/v/16.12.0)
+    (from `16.11.0`, in `dependencies`)
+
 - [#2631](https://github.com/Urigo/accounter-fullstack/pull/2631)
   [`86c8b3e`](https://github.com/Urigo/accounter-fullstack/commit/86c8b3ebea4e3be0c0e99a108ec1cdad8b39e5d8)
   Thanks [@gilgardosh](https://github.com/gilgardosh)! - - **Database Schema Update**: A new
@@ -284,6 +299,29 @@
     retrieved 'adminContext.locality' instead of a hardcoded country name, improving flexibility and
     accuracy.
 
+- [#2649](https://github.com/Urigo/accounter-fullstack/pull/2649)
+  [`c9d936f`](https://github.com/Urigo/accounter-fullstack/commit/c9d936f545d5351df0dc5326c2623266f1ad1f46)
+  Thanks [@gilgardosh](https://github.com/gilgardosh)! - \* **New Charges Auto-Matcher Module**: A
+  new GraphQL module `charges-matcher` has been introduced, complete with its directory structure,
+  TypeScript types, and GraphQL schema definitions for single-match and auto-match functionalities.
+  - **Comprehensive Documentation**: Detailed `SPEC.md`, `PROMPT_PLAN.md`, and `TODO.md` documents
+    have been added, outlining the technical specification, a 17-step implementation plan, and a
+    checklist for the transaction-document matching system.
+  - **Core Matching Logic Implemented**: Helper functions for calculating confidence scores based on
+    amount, currency, business ID, and date proximity have been implemented and thoroughly tested.
+  - **Data Aggregation Providers**: Providers for aggregating multiple transactions and documents
+    into single representations, including filtering, currency/business ID validation, and
+    description concatenation, are now in place.
+  - **Single-Match & Auto-Match Core Functions**: The core logic for finding single matches (with
+    date window filtering and tie-breaking) and for processing charges for auto-matching (including
+    merge direction determination and high-confidence thresholding) has been developed.
+  - **Robust Testing Infrastructure**: A comprehensive testing framework, including mock factories
+    and 494 passing unit and integration tests, has been established, ensuring high code coverage.
+  - **GraphQL Integration**: GraphQL resolvers for `findChargeMatches` and `autoMatchCharges`
+    mutations/queries have been added, and the module is registered in the main GraphQL application.
+  - **Type Safety Improvement**: The `amount` type in the `DocumentSuggestionsProto` interface has
+    been updated from `string` to `number` for enhanced type safety.
+
 - [#2629](https://github.com/Urigo/accounter-fullstack/pull/2629)
   [`6244c1b`](https://github.com/Urigo/accounter-fullstack/commit/6244c1bbafa7029f426bdaf796d830ff62cee006)
   Thanks [@gilgardosh](https://github.com/gilgardosh)! - - **Database Schema Update**: The
@@ -536,7 +574,7 @@
     improved performance.
 
 - [#2658](https://github.com/Urigo/accounter-fullstack/pull/2658)
-  [`b70d33f`](https://github.com/Urigo/accounter-fullstack/commit/b70d33f11d467ddc5a8d6b2869e72653ec08249b)
+  [`7a898a0`](https://github.com/Urigo/accounter-fullstack/commit/7a898a0ff1ee15420ab2532370a1d2f618cc86ab)
   Thanks [@gilgardosh](https://github.com/gilgardosh)! - - Updated all type references from
   `definitions` to `$defs` (represented as `_DOLLAR_defs` in TypeScript)
   - Added client management operations (add, update, delete)
@@ -563,14 +601,16 @@
   where the configuration might be `undefined`.
 - Updated dependencies
   [[`1ae19c6`](https://github.com/Urigo/accounter-fullstack/commit/1ae19c6f8dabd995120862795284dab6e363dc79),
+  [`7fef068`](https://github.com/Urigo/accounter-fullstack/commit/7fef0682c7316153ae5ffde42f97ce7284dd4c9a),
   [`65e3c7f`](https://github.com/Urigo/accounter-fullstack/commit/65e3c7f01993eb4f41244a40feefefa08b31a4e6),
   [`65e3c7f`](https://github.com/Urigo/accounter-fullstack/commit/65e3c7f01993eb4f41244a40feefefa08b31a4e6),
   [`65e3c7f`](https://github.com/Urigo/accounter-fullstack/commit/65e3c7f01993eb4f41244a40feefefa08b31a4e6),
-  [`b70d33f`](https://github.com/Urigo/accounter-fullstack/commit/b70d33f11d467ddc5a8d6b2869e72653ec08249b)]:
-  - @accounter/green-invoice-graphql@0.8.2-alpha-20251102200443-d7162b8ce1dfc629b8b454df17dcec9ed005a052
-  - @accounter/pcn874-generator@0.6.3-alpha-20251102200443-d7162b8ce1dfc629b8b454df17dcec9ed005a052
-  - @accounter/shaam-uniform-format-generator@0.2.2-alpha-20251102200443-d7162b8ce1dfc629b8b454df17dcec9ed005a052
-  - @accounter/shaam6111-generator@0.1.4-alpha-20251102200443-d7162b8ce1dfc629b8b454df17dcec9ed005a052
+  [`7a898a0`](https://github.com/Urigo/accounter-fullstack/commit/7a898a0ff1ee15420ab2532370a1d2f618cc86ab),
+  [`c9d936f`](https://github.com/Urigo/accounter-fullstack/commit/c9d936f545d5351df0dc5326c2623266f1ad1f46)]:
+  - @accounter/green-invoice-graphql@0.8.2-alpha-20251102213150-c9d936f545d5351df0dc5326c2623266f1ad1f46
+  - @accounter/pcn874-generator@0.6.3-alpha-20251102213150-c9d936f545d5351df0dc5326c2623266f1ad1f46
+  - @accounter/shaam-uniform-format-generator@0.2.2-alpha-20251102213150-c9d936f545d5351df0dc5326c2623266f1ad1f46
+  - @accounter/shaam6111-generator@0.1.4-alpha-20251102213150-c9d936f545d5351df0dc5326c2623266f1ad1f46
 
 ## 0.0.7
 

package/dist/green-invoice-graphql/src/mesh-artifacts/index.d.ts

@@ -4,8 +4,8 @@ import type { GetMeshOptions } from '@graphql-mesh/runtime';
 import type { YamlConfig } from '@graphql-mesh/types';
 import { MeshHTTPHandler } from '@graphql-mesh/http';
 import { type ExecuteMeshFn, type SubscribeMeshFn, type MeshContext as BaseMeshContext, type MeshInstance } from '@graphql-mesh/runtime';
-import type { GreenInvoiceNewTypes } from './sources/GreenInvoiceNew/types';
 import type { GreenInvoiceTypes } from './sources/GreenInvoice/types';
+import type { GreenInvoiceNewTypes } from './sources/GreenInvoiceNew/types';
 export type Maybe<T> = T | null;
 export type InputMaybe<T> = Maybe<T>;
 export type Exact<T extends {

package/dist/server/src/__generated__/types.d.ts

@@ -362,6 +362,18 @@ export type AuditOpinionType =
  | 'UNQUALIFIED_WITH_GOING_CONCERN'
 /** 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';
@@ -839,6 +851,20 @@ export type ChargeFilter = {
 };
 /**  filter charges by type  */
 export type ChargeFilterType = 'ALL' | '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';
@@ -2085,6 +2111,14 @@ export type MergeChargesByTransactionReferenceResult = {
     readonly errors?: Maybe<ReadonlyArray<Scalars['String']['output']>>;
     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';
@@ -2142,6 +2176,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>;
@@ -2886,6 +2922,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;
@@ -3065,6 +3103,10 @@ export type QueryFinancialEntityArgs = {
     id: Scalars['UUID']['input'];
 };
 /**  query root  */
+export type QueryFindChargeMatchesArgs = {
+    chargeId: Scalars['UUID']['input'];
+};
+/**  query root  */
 export type QueryGreenInvoiceClientArgs = {
     clientId: Scalars['UUID']['input'];
 };
@@ -4142,6 +4184,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']>;
@@ -4191,6 +4234,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;
@@ -4342,6 +4387,7 @@ export type ResolversTypes = {
     MergeChargesByTransactionReferenceResult: ResolverTypeWrapper<Omit<MergeChargesByTransactionReferenceResult, 'charges'> & {
         charges?: Maybe<ReadonlyArray<ResolversTypes['Charge']>>;
     }>;
+    MergedCharge: ResolverTypeWrapper<MergedCharge>;
     MiscExpense: ResolverTypeWrapper<IGetExpensesByChargeIdsResult>;
     MissingChargeInfo: MissingChargeInfo;
     MonthlyVatCharge: ResolverTypeWrapper<IGetChargesByIdsResult>;
@@ -4512,6 +4558,7 @@ export type ResolversParentTypes = {
     AdminContextInput: AdminContextInput;
     AnnualId: AnnualId;
     AnnualIdInput: AnnualIdInput;
+    AutoMatchChargesResult: AutoMatchChargesResult;
     BalanceTransactions: IGetNormalizedBalanceTransactionsResult;
     BankDeposit: Omit<BankDeposit, 'transactions'> & {
         transactions: ReadonlyArray<ResolversParentTypes['Transaction']>;
@@ -4556,6 +4603,8 @@ export type ResolversParentTypes = {
     CategorizeIntoExistingBusinessTripExpenseInput: CategorizeIntoExistingBusinessTripExpenseInput;
     Charge: ResolversInterfaceTypes<ResolversParentTypes>['Charge'];
     ChargeFilter: ChargeFilter;
+    ChargeMatch: ChargeMatch;
+    ChargeMatchesResult: ChargeMatchesResult;
     ChargeMetadata: IGetChargesByIdsResult;
     ChargeSortBy: ChargeSortBy;
     ChargeSuggestions: Omit<ChargeSuggestions, 'tags'> & {
@@ -4684,6 +4733,7 @@ export type ResolversParentTypes = {
     MergeChargesByTransactionReferenceResult: Omit<MergeChargesByTransactionReferenceResult, 'charges'> & {
         charges?: Maybe<ReadonlyArray<ResolversParentTypes['Charge']>>;
     };
+    MergedCharge: MergedCharge;
     MiscExpense: IGetExpensesByChargeIdsResult;
     MonthlyVatCharge: IGetChargesByIdsResult;
     Mutation: {};
@@ -4928,6 +4978,13 @@ export type AnnualIdResolvers<ContextType = GraphQLModules.Context, ParentType e
     year?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
     __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>;
@@ -5249,6 +5306,15 @@ export type ChargeResolvers<ContextType = GraphQLModules.Context, ParentType ext
     withholdingTax?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
     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>;
@@ -6148,6 +6214,11 @@ export type MergeChargesByTransactionReferenceResultResolvers<ContextType = Grap
     success?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __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>;
@@ -6209,6 +6280,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'>>;
@@ -6478,6 +6550,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'>>;
@@ -6963,6 +7036,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>;
@@ -6990,6 +7064,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>;
@@ -7072,6 +7148,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/dist/server/src/__generated__/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/__generated__/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAs3BrD,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAyX7B,OAAO,EAAE,QAAQ,EAAE,CAAC;AAuLpB,OAAO,EAAE,YAAY,EAAE,CAAC;AA2lCxB,OAAO,EAAE,iBAAiB,EAAE,CAAC;AA85D7B,OAAO,EAAE,oBAAoB,EAAE,CAAC"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/__generated__/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAm5BrD,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAyX7B,OAAO,EAAE,QAAQ,EAAE,CAAC;AAuLpB,OAAO,EAAE,YAAY,EAAE,CAAC;AAomCxB,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAw6D7B,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/server/src/modules/charges-matcher/__generated__/types.d.ts

@@ -0,0 +1,68 @@
+import * as Types from "../../../__generated__/types.js";
+import * as gm from "graphql-modules";
+export declare 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[];
+        };
+    }
+    export {};
+}

package/dist/server/src/modules/charges-matcher/__generated__/types.js

@@ -0,0 +1,7 @@
+export var ChargesMatcherModule;
+(function (ChargesMatcherModule) {
+    ;
+    ;
+    ;
+})(ChargesMatcherModule || (ChargesMatcherModule = {}));
+//# sourceMappingURL=types.js.map

package/dist/server/src/modules/charges-matcher/__generated__/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../../src/modules/charges-matcher/__generated__/types.ts"],"names":[],"mappings":"AAEA,MAAM,KAAW,oBAAoB,CAoEpC;AApED,WAAiB,oBAAoB;IAQlC,CAAC;IAwBD,CAAC;IAmCD,CAAC;AACJ,CAAC,EApEgB,oBAAoB,KAApB,oBAAoB,QAoEpC"}

package/dist/server/src/modules/charges-matcher/__tests__/amount-confidence.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/src/modules/charges-matcher/__tests__/amount-confidence.test.js

@@ -0,0 +1,218 @@
+import { describe, it, expect } from 'vitest';
+import { calculateAmountConfidence } from '../helpers/amount-confidence.helper.js';
+describe('calculateAmountConfidence', () => {
+    describe('exact matches', () => {
+        it('should return 1.0 for exact match with positive amounts', () => {
+            expect(calculateAmountConfidence(100, 100)).toBe(1.0);
+            expect(calculateAmountConfidence(50.5, 50.5)).toBe(1.0);
+            expect(calculateAmountConfidence(0.01, 0.01)).toBe(1.0);
+        });
+        it('should return 1.0 for exact match with negative amounts', () => {
+            expect(calculateAmountConfidence(-100, -100)).toBe(1.0);
+            expect(calculateAmountConfidence(-50.5, -50.5)).toBe(1.0);
+        });
+        it('should return 1.0 for zero amounts', () => {
+            expect(calculateAmountConfidence(0, 0)).toBe(1.0);
+        });
+        it('should return 1.0 for matching absolute values with different signs', () => {
+            // Since we compare absolute values, sign differences shouldn't matter for exact amounts
+            expect(calculateAmountConfidence(100, 100)).toBe(1.0);
+            expect(calculateAmountConfidence(-100, -100)).toBe(1.0);
+        });
+    });
+    describe('amounts within 1 unit', () => {
+        it('should return 0.9 for amounts within 0.5 units', () => {
+            expect(calculateAmountConfidence(100, 100.5)).toBe(0.9);
+            expect(calculateAmountConfidence(100.5, 100)).toBe(0.9);
+            expect(calculateAmountConfidence(50, 50.3)).toBe(0.9);
+        });
+        it('should return 0.9 for amounts at exactly 1 unit difference', () => {
+            expect(calculateAmountConfidence(100, 101)).toBe(0.9);
+            expect(calculateAmountConfidence(101, 100)).toBe(0.9);
+            expect(calculateAmountConfidence(50, 51)).toBe(0.9);
+        });
+        it('should return 0.9 for amounts just under 1 unit difference', () => {
+            expect(calculateAmountConfidence(100, 100.99)).toBe(0.9);
+            expect(calculateAmountConfidence(100.99, 100)).toBe(0.9);
+        });
+        it('should return 0.9 for negative amounts within 1 unit', () => {
+            expect(calculateAmountConfidence(-100, -100.5)).toBe(0.9);
+            expect(calculateAmountConfidence(-100, -101)).toBe(0.9);
+        });
+    });
+    describe('amounts with differences between 1 unit and 20%', () => {
+        it('should return value between 0.0 and 0.7 for 1.5 units difference', () => {
+            const confidence = calculateAmountConfidence(100, 101.5);
+            expect(confidence).toBeGreaterThan(0.0);
+            expect(confidence).toBeLessThan(0.7);
+        });
+        it('should return value between 0.0 and 0.7 for 2 units difference', () => {
+            const confidence = calculateAmountConfidence(100, 102);
+            expect(confidence).toBeGreaterThan(0.0);
+            expect(confidence).toBeLessThan(0.7);
+        });
+        it('should return value between 0.0 and 0.7 for 5 units difference (on 100)', () => {
+            const confidence = calculateAmountConfidence(100, 105);
+            expect(confidence).toBeGreaterThan(0.0);
+            expect(confidence).toBeLessThan(0.7);
+            // 5% difference should be roughly in the middle
+            expect(confidence).toBeGreaterThan(0.3);
+        });
+        it('should return value between 0.0 and 0.7 for 10 units difference (on 100)', () => {
+            const confidence = calculateAmountConfidence(100, 110);
+            expect(confidence).toBeGreaterThan(0.0);
+            expect(confidence).toBeLessThan(0.7);
+            // 10% difference should be lower
+            expect(confidence).toBeLessThan(0.4);
+        });
+        it('should demonstrate linear degradation', () => {
+            // For amounts where 1 unit = 1%, we can test linear degradation more precisely
+            // Starting from just over 1% to just under 20%
+            // At around 1% (just over 1 unit on 100): should be close to 0.7
+            const conf1 = calculateAmountConfidence(100, 101.5); // 1.5%
+            // At around 10% (middle of range): should be around 0.35
+            const conf10 = calculateAmountConfidence(100, 110); // 10%
+            // At around 19% (near end): should be close to 0.0
+            const conf19 = calculateAmountConfidence(100, 119); // 19%
+            // Verify degradation order
+            expect(conf1).toBeGreaterThan(conf10);
+            expect(conf10).toBeGreaterThan(conf19);
+        });
+    });
+    describe('amounts at exactly 20% difference', () => {
+        it('should return 0.0 for exactly 20% difference', () => {
+            expect(calculateAmountConfidence(100, 120)).toBe(0.0);
+            expect(calculateAmountConfidence(120, 100)).toBe(0.0);
+            expect(calculateAmountConfidence(50, 60)).toBe(0.0);
+        });
+        it('should return 0.0 for just under 20% difference (19.99%)', () => {
+            // Just under 20% should still be very close to 0
+            const confidence = calculateAmountConfidence(100, 119.9);
+            expect(confidence).toBeLessThanOrEqual(0.01);
+        });
+    });
+    describe('amounts beyond 20% difference', () => {
+        it('should return 0.0 for 25% difference', () => {
+            expect(calculateAmountConfidence(100, 125)).toBe(0.0);
+        });
+        it('should return 0.0 for 50% difference', () => {
+            expect(calculateAmountConfidence(100, 150)).toBe(0.0);
+        });
+        it('should return 0.0 for 100% difference', () => {
+            expect(calculateAmountConfidence(100, 200)).toBe(0.0);
+        });
+        it('should return 0.0 for very large differences', () => {
+            expect(calculateAmountConfidence(100, 1000)).toBe(0.0);
+            expect(calculateAmountConfidence(10, 500)).toBe(0.0);
+        });
+    });
+    describe('edge cases with negative amounts', () => {
+        it('should handle negative transaction amount', () => {
+            expect(calculateAmountConfidence(-100, -100)).toBe(1.0);
+            expect(calculateAmountConfidence(-100, -101)).toBe(0.9);
+            expect(calculateAmountConfidence(-100, -105)).toBeGreaterThan(0.0);
+            expect(calculateAmountConfidence(-100, -120)).toBe(0.0);
+        });
+        it('should handle negative document amount', () => {
+            expect(calculateAmountConfidence(-100, -100)).toBe(1.0);
+            expect(calculateAmountConfidence(-101, -100)).toBe(0.9);
+        });
+        it('should handle both amounts negative', () => {
+            expect(calculateAmountConfidence(-50, -50.5)).toBe(0.9);
+            expect(calculateAmountConfidence(-100, -110)).toBeGreaterThan(0.0);
+        });
+    });
+    describe('edge cases with very small amounts', () => {
+        it('should handle very small amounts correctly', () => {
+            expect(calculateAmountConfidence(0.1, 0.1)).toBe(1.0);
+            expect(calculateAmountConfidence(0.01, 0.01)).toBe(1.0);
+        });
+        it('should return 0.9 for small amounts within 1 unit', () => {
+            // Even though 1 unit is huge compared to 0.1, it should still return 0.9
+            expect(calculateAmountConfidence(0.1, 1.0)).toBe(0.9);
+            expect(calculateAmountConfidence(0.5, 1.5)).toBe(0.9);
+        });
+        it('should handle small amounts with percentage differences correctly', () => {
+            // 0.1 to 0.12 has a difference of 0.02, which is within 1 unit, so returns 0.9
+            expect(calculateAmountConfidence(0.1, 0.12)).toBe(0.9);
+            // 0.1 to 0.11 has a difference of 0.01, which is within 1 unit, so returns 0.9
+            expect(calculateAmountConfidence(0.1, 0.11)).toBe(0.9);
+            // 0.1 to 1.2 has >1 unit difference (1.1) and is also >20%, so returns 0.0
+            expect(calculateAmountConfidence(0.1, 1.2)).toBe(0.0);
+        });
+    });
+    describe('edge cases with zero', () => {
+        it('should handle zero in transaction amount', () => {
+            expect(calculateAmountConfidence(0, 0)).toBe(1.0);
+        });
+        it('should handle zero vs non-zero amounts', () => {
+            // 0 to 1 is within 1 unit
+            expect(calculateAmountConfidence(0, 1)).toBe(0.9);
+            expect(calculateAmountConfidence(1, 0)).toBe(0.9);
+            // 0 to >1 means one amount is 0, which makes percentage calculation undefined
+            // The spec requires us to handle this gracefully - since we can't calculate percentage
+            // and the difference is >1, we return 0.0
+            expect(calculateAmountConfidence(0, 2)).toBe(0.0);
+        });
+    });
+    describe('formula verification for linear degradation', () => {
+        it('should verify the linear formula in the middle range', () => {
+            // Using base amount of 100 for easier percentage calculation
+            // 1 unit = 1% on 100
+            // Range is from 1% to 20%
+            // Confidence degrades linearly from 0.7 to 0.0
+            // At 1% (101): should be close to 0.7 (but we're just over 1 unit)
+            const conf1 = calculateAmountConfidence(100, 101.01);
+            expect(conf1).toBeCloseTo(0.7, 1);
+            // At 10.5% (halfway between 1% and 20%): should be around 0.35
+            const conf10_5 = calculateAmountConfidence(100, 110.5);
+            expect(conf10_5).toBeCloseTo(0.35, 1);
+            // At 19.9% (just before 20%): should be close to 0.0
+            const conf19_9 = calculateAmountConfidence(100, 119.9);
+            expect(conf19_9).toBeCloseTo(0.0, 1);
+        });
+        it('should verify degradation is proportional across the range', () => {
+            // Calculate several points and verify linear relationship
+            const base = 100;
+            // Points at different percentages in the degradation range
+            const conf_2pct = calculateAmountConfidence(base, 102); // ~2%
+            const conf_5pct = calculateAmountConfidence(base, 105); // 5%
+            const conf_10pct = calculateAmountConfidence(base, 110); // 10%
+            const conf_15pct = calculateAmountConfidence(base, 115); // 15%
+            // Each should be progressively smaller
+            expect(conf_2pct).toBeGreaterThan(conf_5pct);
+            expect(conf_5pct).toBeGreaterThan(conf_10pct);
+            expect(conf_10pct).toBeGreaterThan(conf_15pct);
+        });
+    });
+    describe('return value precision', () => {
+        it('should return values rounded to 2 decimal places', () => {
+            const confidence = calculateAmountConfidence(100, 105);
+            // Check that the value has at most 2 decimal places
+            const decimalPlaces = (confidence.toString().split('.')[1] || '').length;
+            expect(decimalPlaces).toBeLessThanOrEqual(2);
+        });
+        it('should handle rounding correctly for edge values', () => {
+            // Test various amounts that might produce values needing rounding
+            const amounts = [
+                [100, 102.5],
+                [100, 107.3],
+                [100, 113.7],
+                [50, 53.3],
+            ];
+            amounts.forEach(([amt1, amt2]) => {
+                const confidence = calculateAmountConfidence(amt1, amt2);
+                const decimalPlaces = (confidence.toString().split('.')[1] || '').length;
+                expect(decimalPlaces).toBeLessThanOrEqual(2);
+            });
+        });
+    });
+    describe('symmetry', () => {
+        it('should return same confidence regardless of parameter order', () => {
+            expect(calculateAmountConfidence(100, 105)).toBe(calculateAmountConfidence(105, 100));
+            expect(calculateAmountConfidence(50, 60)).toBe(calculateAmountConfidence(60, 50));
+            expect(calculateAmountConfidence(100, 101)).toBe(calculateAmountConfidence(101, 100));
+        });
+    });
+});
+//# sourceMappingURL=amount-confidence.test.js.map