import { ChargeSortByField } from '@shared/enums';
import { Currency } from '@shared/enums';
import { DocumentType } from '@shared/enums';
import { MissingChargeInfo } from '@shared/enums';
import { TransactionDirection } from '@shared/enums';
import { TimelessDateString } from '@shared/types';
import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
import { IGetChargesByIdsResult } from '@modules/charges/types.js';
import { IGetFinancialAccountsByOwnerIdsResult } from '@modules/financial-accounts/types.js';
import { IGetBusinessesByIdsResult, IGetFinancialEntitiesByIdsResult, IGetAllTaxCategoriesResult } from '@modules/financial-entities/types.js';
import { BusinessTransactionProto, RawBusinessTransactionsSum, CorporateTaxRulingComplianceReportProto, DocumentSuggestionsProto, LedgerBalanceUnbalancedEntityProto, LedgerRecordsProto } from '@shared/types';
import { BusinessTripProto, IGetBusinessTripsAccommodationsExpensesByIdsResult, IGetBusinessTripsAttendeesByBusinessTripIdsResult, IGetBusinessTripsFlightsExpensesByIdsResult, IGetBusinessTripsOtherExpensesByIdsResult, IGetBusinessTripsTravelAndSubsistenceExpensesByIdsResult, IGetBusinessTripsCarRentalExpensesByIdsResult } from '@modules/business-trips/types.js';
import { IGetTransactionsByIdsResult } from '@modules/transactions/types.js';
import { IGetCorporateTaxesByCorporateIdsResult } from '@modules/corporate-taxes/types.js';
import { IGetAllCountriesResult } from '@modules/countries/types.js';
import { IGetAllDocumentsResult } from '@modules/documents/types.js';
import { IGetAllDepreciationCategoriesResult, IGetDepreciationRecordsByIdsResult } from '@modules/depreciation/types.js';
import { IGetTemplateResult, ProfitAndLossReportYearProto, CommentaryRecordProto, CommentarySubRecordProto, TaxReportYearProto } from '@modules/reports/types.js';
import { MonthDataProto } from '@modules/charts/types.js';
import { IGetLedgerRecordsByChargesIdsResult } from '@modules/ledger/types.js';
import { IGetExpensesByChargeIdsResult } from '@modules/misc-expenses/types.js';
import { IGetAllSalaryRecordsResult } from '@modules/salaries/types.js';
import { IGetSortCodesByIdsResult } from '@modules/sort-codes/types.js';
import { IGetAllTagsResult } from '@modules/tags/types.js';
import { RawVatReportRecord } from '@modules/reports/helpers/vat-report.helper.js';
export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
export type RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> };
export type EnumResolverSignature<T, AllowedValues = any> = { [key in keyof T]?: AllowedValues };
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: { input: string; output: string; }
  String: { input: string; output: string; }
  Boolean: { input: boolean; output: boolean; }
  Int: { input: number; output: number; }
  Float: { input: number; output: number; }
  /**  Date  */
  DateTime: { input: Date; output: Date; }
  /**  mock  */
  DividendMock: { input: any; output: any; }
  /**  File  */
  FileScalar: { input: File | Blob; output: string; }
  /**  Rate  */
  Rate: { input: any; output: any; }
  /**  Date with no time of day  */
  TimelessDate: { input: TimelessDateString; output: TimelessDateString; }
  /**  URL  */
  URL: { input: URL | string; output: URL | string; }
  /**  UUID  */
  UUID: { input: string; output: string; }
  /**  mock  */
  VatMock: { input: any; output: any; }
};

/**  represents accountant approval status  */
export type AccountantStatus =
  | 'APPROVED'
  | 'PENDING'
  | 'UNAPPROVED';

/**  the input for adding a new business trip accommodation expense  */
export type AddBusinessTripAccommodationsExpenseInput = {
  readonly amount?: InputMaybe<Scalars['Float']['input']>;
  readonly attendeesStay?: InputMaybe<ReadonlyArray<BusinessTripAttendeeStayInput>>;
  readonly businessTripId: Scalars['UUID']['input'];
  readonly country?: InputMaybe<Scalars['String']['input']>;
  readonly currency?: InputMaybe<Currency>;
  readonly date?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly employeeBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  readonly nightsCount?: InputMaybe<Scalars['Int']['input']>;
  readonly valueDate?: InputMaybe<Scalars['TimelessDate']['input']>;
};

/**  the input for adding a new business trip T&S expense  */
export type AddBusinessTripCarRentalExpenseInput = {
  readonly amount?: InputMaybe<Scalars['Float']['input']>;
  readonly businessTripId: Scalars['UUID']['input'];
  readonly currency?: InputMaybe<Currency>;
  readonly date?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly days?: InputMaybe<Scalars['Int']['input']>;
  readonly employeeBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  readonly isFuelExpense?: InputMaybe<Scalars['Boolean']['input']>;
  readonly valueDate?: InputMaybe<Scalars['TimelessDate']['input']>;
};

/**  the input for adding a new business trip flights expense  */
export type AddBusinessTripFlightsExpenseInput = {
  readonly amount?: InputMaybe<Scalars['Float']['input']>;
  readonly attendeeIds?: InputMaybe<ReadonlyArray<Scalars['UUID']['input']>>;
  readonly businessTripId: Scalars['UUID']['input'];
  readonly currency?: InputMaybe<Currency>;
  readonly date?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly employeeBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  readonly flightClass?: InputMaybe<FlightClass>;
  readonly path?: InputMaybe<ReadonlyArray<Scalars['String']['input']>>;
  readonly valueDate?: InputMaybe<Scalars['TimelessDate']['input']>;
};

/**  the input for adding a new business trip other expense  */
export type AddBusinessTripOtherExpenseInput = {
  readonly amount?: InputMaybe<Scalars['Float']['input']>;
  readonly businessTripId: Scalars['UUID']['input'];
  readonly currency?: InputMaybe<Currency>;
  readonly date?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly deductibleExpense?: InputMaybe<Scalars['Boolean']['input']>;
  readonly description?: InputMaybe<Scalars['String']['input']>;
  readonly employeeBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  readonly valueDate?: InputMaybe<Scalars['TimelessDate']['input']>;
};

/**  the input for adding a new business trip T&S expense  */
export type AddBusinessTripTravelAndSubsistenceExpenseInput = {
  readonly amount?: InputMaybe<Scalars['Float']['input']>;
  readonly businessTripId: Scalars['UUID']['input'];
  readonly currency?: InputMaybe<Currency>;
  readonly date?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly employeeBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  readonly expenseType?: InputMaybe<Scalars['String']['input']>;
  readonly valueDate?: InputMaybe<Scalars['TimelessDate']['input']>;
};

/**  charge of bank deposits  */
export type BankDepositCharge = Charge & {
  readonly __typename?: 'BankDepositCharge';
  readonly accountantApproval: AccountantStatus;
  readonly additionalDocuments: ReadonlyArray<Document>;
  readonly conversion?: Maybe<Scalars['Boolean']['output']>;
  readonly counterparty?: Maybe<FinancialEntity>;
  readonly exchangeRates?: Maybe<ExchangeRates>;
  readonly id: Scalars['UUID']['output'];
  readonly isInvoicePaymentDifferentCurrency?: Maybe<Scalars['Boolean']['output']>;
  readonly ledger: Ledger;
  readonly metadata?: Maybe<ChargeMetadata>;
  readonly minDebitDate?: Maybe<Scalars['DateTime']['output']>;
  readonly minDocumentsDate?: Maybe<Scalars['DateTime']['output']>;
  readonly minEventDate?: Maybe<Scalars['DateTime']['output']>;
  readonly miscExpenses: ReadonlyArray<MiscExpense>;
  readonly missingInfoSuggestions?: Maybe<ChargeSuggestions>;
  readonly optionalVAT?: Maybe<Scalars['Boolean']['output']>;
  readonly owner: Business;
  readonly property?: Maybe<Scalars['Boolean']['output']>;
  readonly salary?: Maybe<Scalars['Boolean']['output']>;
  readonly tags: ReadonlyArray<Tag>;
  readonly taxCategory?: Maybe<TaxCategory>;
  readonly totalAmount?: Maybe<FinancialAmount>;
  readonly transactions: ReadonlyArray<Transaction>;
  readonly userDescription?: Maybe<Scalars['String']['output']>;
  readonly validationData?: Maybe<ValidationData>;
  readonly vat?: Maybe<FinancialAmount>;
  readonly withholdingTax?: Maybe<FinancialAmount>;
  readonly yearsOfRelevance?: Maybe<ReadonlyArray<YearOfRelevance>>;
};

/**  represent a single bank account */
export type BankFinancialAccount = FinancialAccount & {
  readonly __typename?: 'BankFinancialAccount';
  /**  the external identifier of the bank account  */
  readonly accountNumber: Scalars['String']['output'];
  readonly bankNumber: Scalars['String']['output'];
  readonly branchNumber: Scalars['String']['output'];
  readonly charges: ReadonlyArray<Charge>;
  readonly id: Scalars['UUID']['output'];
  readonly name: Scalars['String']['output'];
  readonly type: Scalars['String']['output'];
};


/**  represent a single bank account */
export type BankFinancialAccountChargesArgs = {
  filter?: InputMaybe<ChargeFilter>;
};

/**  represent a financial entity of any type that may hold financial accounts (company, business, individual)  */
export type Business = {
  readonly accounts: ReadonlyArray<FinancialAccount>;
  readonly charges: PaginatedCharges;
  readonly id: Scalars['UUID']['output'];
  readonly name: Scalars['String']['output'];
  readonly sortCode?: Maybe<SortCode>;
};


/**  represent a financial entity of any type that may hold financial accounts (company, business, individual)  */
export type BusinessChargesArgs = {
  filter?: InputMaybe<ChargeFilter>;
  limit?: InputMaybe<Scalars['Int']['input']>;
  page?: InputMaybe<Scalars['Int']['input']>;
};

/**  single business transaction info  */
export type BusinessTransaction = {
  readonly __typename?: 'BusinessTransaction';
  readonly amount: FinancialAmount;
  readonly business: FinancialEntity;
  readonly chargeId: Scalars['UUID']['output'];
  readonly counterAccount?: Maybe<FinancialEntity>;
  readonly details?: Maybe<Scalars['String']['output']>;
  readonly foreignAmount?: Maybe<FinancialAmount>;
  readonly invoiceDate: Scalars['TimelessDate']['output'];
  readonly reference?: Maybe<Scalars['String']['output']>;
};

/**  single business transaction summery  */
export type BusinessTransactionSum = {
  readonly __typename?: 'BusinessTransactionSum';
  readonly business: FinancialEntity;
  readonly credit: FinancialAmount;
  readonly debit: FinancialAmount;
  readonly foreignCurrenciesSum: ReadonlyArray<ForeignCurrencySum>;
  readonly total: FinancialAmount;
};

/**  input variables for businessTransactions  */
export type BusinessTransactionsFilter = {
  readonly businessIDs?: InputMaybe<ReadonlyArray<Scalars['UUID']['input']>>;
  readonly fromDate?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly includeRevaluation?: InputMaybe<Scalars['Boolean']['input']>;
  readonly ownerIds?: InputMaybe<ReadonlyArray<Scalars['UUID']['input']>>;
  readonly toDate?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly type?: InputMaybe<FinancialEntityType>;
};

/**  result type for businessTransactionsFromLedgerRecords  */
export type BusinessTransactionsFromLedgerRecordsResult = BusinessTransactionsFromLedgerRecordsSuccessfulResult | CommonError;

/**  result type for businessTransactionsFromLedgerRecords */
export type BusinessTransactionsFromLedgerRecordsSuccessfulResult = {
  readonly __typename?: 'BusinessTransactionsFromLedgerRecordsSuccessfulResult';
  readonly businessTransactions: ReadonlyArray<BusinessTransaction>;
};

/**  result type for businessTransactionsSumFromLedgerRecords  */
export type BusinessTransactionsSumFromLedgerRecordsResult = BusinessTransactionsSumFromLedgerRecordsSuccessfulResult | CommonError;

/**  result type for businessTransactionsSumFromLedgerRecords */
export type BusinessTransactionsSumFromLedgerRecordsSuccessfulResult = {
  readonly __typename?: 'BusinessTransactionsSumFromLedgerRecordsSuccessfulResult';
  readonly businessTransactionsSum: ReadonlyArray<BusinessTransactionSum>;
};

/**  represent a business trip  */
export type BusinessTrip = {
  readonly __typename?: 'BusinessTrip';
  readonly accommodationExpenses: ReadonlyArray<BusinessTripAccommodationExpense>;
  readonly accountantApproval: AccountantStatus;
  readonly attendees: ReadonlyArray<BusinessTripAttendee>;
  readonly carRentalExpenses: ReadonlyArray<BusinessTripCarRentalExpense>;
  readonly dates?: Maybe<DateRange>;
  readonly destination?: Maybe<Country>;
  readonly flightExpenses: ReadonlyArray<BusinessTripFlightExpense>;
  readonly id: Scalars['UUID']['output'];
  readonly name: Scalars['String']['output'];
  readonly otherExpenses: ReadonlyArray<BusinessTripOtherExpense>;
  readonly purpose?: Maybe<Scalars['String']['output']>;
  readonly summary: BusinessTripSummary;
  readonly travelAndSubsistenceExpenses: ReadonlyArray<BusinessTripTravelAndSubsistenceExpense>;
  readonly uncategorizedTransactions: ReadonlyArray<Maybe<UncategorizedTransaction>>;
};

/**  represent a business trip accommodation expense  */
export type BusinessTripAccommodationExpense = BusinessTripExpense & {
  readonly __typename?: 'BusinessTripAccommodationExpense';
  readonly amount?: Maybe<FinancialAmount>;
  readonly attendeesStay: ReadonlyArray<BusinessTripAttendeeStay>;
  readonly businessTrip: BusinessTrip;
  readonly charges?: Maybe<ReadonlyArray<Charge>>;
  readonly country?: Maybe<Scalars['String']['output']>;
  readonly date?: Maybe<Scalars['TimelessDate']['output']>;
  readonly employee?: Maybe<FinancialEntity>;
  readonly id: Scalars['UUID']['output'];
  readonly nightsCount?: Maybe<Scalars['Int']['output']>;
  readonly payedByEmployee?: Maybe<Scalars['Boolean']['output']>;
  readonly transactions?: Maybe<ReadonlyArray<Transaction>>;
  readonly valueDate?: Maybe<Scalars['TimelessDate']['output']>;
};

/**  represent business trip attendee  */
export type BusinessTripAttendee = {
  readonly __typename?: 'BusinessTripAttendee';
  readonly accommodations: ReadonlyArray<BusinessTripAccommodationExpense>;
  readonly arrivalDate?: Maybe<Scalars['TimelessDate']['output']>;
  readonly business?: Maybe<Business>;
  readonly departureDate?: Maybe<Scalars['TimelessDate']['output']>;
  readonly flights: ReadonlyArray<BusinessTripFlightExpense>;
  readonly id: Scalars['UUID']['output'];
  readonly name: Scalars['String']['output'];
};

/**  represent a business trip attendee accommodation stay info  */
export type BusinessTripAttendeeStay = {
  readonly __typename?: 'BusinessTripAttendeeStay';
  readonly attendee: BusinessTripAttendee;
  readonly id: Scalars['UUID']['output'];
  readonly nightsCount: Scalars['Int']['output'];
};

/**  the input for attendee accommodation stay info  */
export type BusinessTripAttendeeStayInput = {
  readonly attendeeId: Scalars['UUID']['input'];
  readonly nightsCount: Scalars['Int']['input'];
};

/**  the input for updating a business trip attendee  */
export type BusinessTripAttendeeUpdateInput = {
  readonly arrivalDate?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly attendeeId: Scalars['UUID']['input'];
  readonly businessTripId: Scalars['UUID']['input'];
  readonly departureDate?: InputMaybe<Scalars['TimelessDate']['input']>;
};

/**  represent a business trip car rental expense  */
export type BusinessTripCarRentalExpense = BusinessTripExpense & {
  readonly __typename?: 'BusinessTripCarRentalExpense';
  readonly amount?: Maybe<FinancialAmount>;
  readonly businessTrip: BusinessTrip;
  readonly charges?: Maybe<ReadonlyArray<Charge>>;
  readonly date?: Maybe<Scalars['TimelessDate']['output']>;
  /**  הוצאה מוכרת  */
  readonly days: Scalars['Int']['output'];
  readonly employee?: Maybe<FinancialEntity>;
  readonly id: Scalars['UUID']['output'];
  /**  פירוט  */
  readonly isFuelExpense: Scalars['Boolean']['output'];
  readonly payedByEmployee?: Maybe<Scalars['Boolean']['output']>;
  readonly transactions?: Maybe<ReadonlyArray<Transaction>>;
  readonly valueDate?: Maybe<Scalars['TimelessDate']['output']>;
};

/**  charge of dividends  */
export type BusinessTripCharge = Charge & {
  readonly __typename?: 'BusinessTripCharge';
  readonly accountantApproval: AccountantStatus;
  readonly additionalDocuments: ReadonlyArray<Document>;
  readonly businessTrip?: Maybe<BusinessTrip>;
  readonly conversion?: Maybe<Scalars['Boolean']['output']>;
  readonly counterparty?: Maybe<FinancialEntity>;
  readonly exchangeRates?: Maybe<ExchangeRates>;
  readonly id: Scalars['UUID']['output'];
  readonly isInvoicePaymentDifferentCurrency?: Maybe<Scalars['Boolean']['output']>;
  readonly ledger: Ledger;
  readonly metadata?: Maybe<ChargeMetadata>;
  readonly minDebitDate?: Maybe<Scalars['DateTime']['output']>;
  readonly minDocumentsDate?: Maybe<Scalars['DateTime']['output']>;
  readonly minEventDate?: Maybe<Scalars['DateTime']['output']>;
  readonly miscExpenses: ReadonlyArray<MiscExpense>;
  readonly missingInfoSuggestions?: Maybe<ChargeSuggestions>;
  readonly optionalVAT?: Maybe<Scalars['Boolean']['output']>;
  readonly owner: Business;
  readonly property?: Maybe<Scalars['Boolean']['output']>;
  readonly salary?: Maybe<Scalars['Boolean']['output']>;
  readonly tags: ReadonlyArray<Tag>;
  readonly taxCategory?: Maybe<TaxCategory>;
  readonly totalAmount?: Maybe<FinancialAmount>;
  readonly transactions: ReadonlyArray<Transaction>;
  readonly userDescription?: Maybe<Scalars['String']['output']>;
  readonly validationData?: Maybe<ValidationData>;
  readonly vat?: Maybe<FinancialAmount>;
  readonly withholdingTax?: Maybe<FinancialAmount>;
  readonly yearsOfRelevance?: Maybe<ReadonlyArray<YearOfRelevance>>;
};

/**  business trip expense prototype  */
export type BusinessTripExpense = {
  readonly amount?: Maybe<FinancialAmount>;
  readonly businessTrip: BusinessTrip;
  readonly charges?: Maybe<ReadonlyArray<Charge>>;
  readonly date?: Maybe<Scalars['TimelessDate']['output']>;
  readonly employee?: Maybe<FinancialEntity>;
  readonly id: Scalars['UUID']['output'];
  /**  שולם על ידי העובד  */
  readonly payedByEmployee?: Maybe<Scalars['Boolean']['output']>;
  readonly transactions?: Maybe<ReadonlyArray<Transaction>>;
  readonly valueDate?: Maybe<Scalars['TimelessDate']['output']>;
};

/**  represent category type of business trip summary  */
export type BusinessTripExpenseCategories =
  | 'ACCOMMODATION'
  | 'CAR_RENTAL'
  | 'FLIGHT'
  | 'OTHER'
  | 'TRAVEL_AND_SUBSISTENCE';

/**  represent a business trip flight expense  */
export type BusinessTripFlightExpense = BusinessTripExpense & {
  readonly __typename?: 'BusinessTripFlightExpense';
  readonly amount?: Maybe<FinancialAmount>;
  readonly attendees: ReadonlyArray<BusinessTripAttendee>;
  readonly businessTrip: BusinessTrip;
  readonly charges?: Maybe<ReadonlyArray<Charge>>;
  readonly class?: Maybe<Scalars['String']['output']>;
  readonly date?: Maybe<Scalars['TimelessDate']['output']>;
  readonly employee?: Maybe<FinancialEntity>;
  readonly id: Scalars['UUID']['output'];
  readonly path?: Maybe<ReadonlyArray<Scalars['String']['output']>>;
  readonly payedByEmployee?: Maybe<Scalars['Boolean']['output']>;
  readonly transactions?: Maybe<ReadonlyArray<Transaction>>;
  readonly valueDate?: Maybe<Scalars['TimelessDate']['output']>;
};

/**  represent a business trip other expense  */
export type BusinessTripOtherExpense = BusinessTripExpense & {
  readonly __typename?: 'BusinessTripOtherExpense';
  readonly amount?: Maybe<FinancialAmount>;
  readonly businessTrip: BusinessTrip;
  readonly charges?: Maybe<ReadonlyArray<Charge>>;
  readonly date?: Maybe<Scalars['TimelessDate']['output']>;
  /**  הוצאה מוכרת  */
  readonly deductibleExpense?: Maybe<Scalars['Boolean']['output']>;
  /**  פירוט  */
  readonly description?: Maybe<Scalars['String']['output']>;
  readonly employee?: Maybe<FinancialEntity>;
  readonly id: Scalars['UUID']['output'];
  readonly payedByEmployee?: Maybe<Scalars['Boolean']['output']>;
  readonly transactions?: Maybe<ReadonlyArray<Transaction>>;
  readonly valueDate?: Maybe<Scalars['TimelessDate']['output']>;
};

/**  represent business trip summary data  */
export type BusinessTripSummary = {
  readonly __typename?: 'BusinessTripSummary';
  readonly errors?: Maybe<ReadonlyArray<Scalars['String']['output']>>;
  readonly excessExpenditure?: Maybe<FinancialAmount>;
  readonly excessTax?: Maybe<Scalars['Float']['output']>;
  readonly rows: ReadonlyArray<BusinessTripSummaryRow>;
};

/**  represent category type of business trip summary  */
export type BusinessTripSummaryCategories =
  | 'ACCOMMODATION'
  | 'CAR_RENTAL'
  | 'FLIGHT'
  | 'OTHER'
  | 'TOTAL'
  | 'TRAVEL_AND_SUBSISTENCE';

/**  represent business trip summary data row  */
export type BusinessTripSummaryRow = {
  readonly __typename?: 'BusinessTripSummaryRow';
  readonly excessExpenditure?: Maybe<FinancialAmount>;
  readonly maxTaxableForeignCurrency: FinancialAmount;
  readonly maxTaxableLocalCurrency?: Maybe<FinancialAmount>;
  readonly taxableForeignCurrency: FinancialAmount;
  readonly taxableLocalCurrency?: Maybe<FinancialAmount>;
  readonly totalForeignCurrency: FinancialAmount;
  readonly totalLocalCurrency?: Maybe<FinancialAmount>;
  readonly type: BusinessTripSummaryCategories;
};

/**  represent a business trip travel and subsistence expense  */
export type BusinessTripTravelAndSubsistenceExpense = BusinessTripExpense & {
  readonly __typename?: 'BusinessTripTravelAndSubsistenceExpense';
  readonly amount?: Maybe<FinancialAmount>;
  readonly businessTrip: BusinessTrip;
  readonly charges?: Maybe<ReadonlyArray<Charge>>;
  readonly date?: Maybe<Scalars['TimelessDate']['output']>;
  readonly employee?: Maybe<FinancialEntity>;
  /**  סוג ההוצאה  */
  readonly expenseType?: Maybe<Scalars['String']['output']>;
  readonly id: Scalars['UUID']['output'];
  readonly payedByEmployee?: Maybe<Scalars['Boolean']['output']>;
  readonly transactions?: Maybe<ReadonlyArray<Transaction>>;
  readonly valueDate?: Maybe<Scalars['TimelessDate']['output']>;
};

/**  represent a single credit card  */
export type CardFinancialAccount = FinancialAccount & {
  readonly __typename?: 'CardFinancialAccount';
  readonly charges: ReadonlyArray<Charge>;
  readonly fourDigits: Scalars['String']['output'];
  readonly id: Scalars['UUID']['output'];
  readonly name: Scalars['String']['output'];
  /**  the external identifier of the card  */
  readonly number: Scalars['String']['output'];
  readonly type: Scalars['String']['output'];
};


/**  represent a single credit card  */
export type CardFinancialAccountChargesArgs = {
  filter?: InputMaybe<ChargeFilter>;
};

/**  the input for categorizing a business trip expense  */
export type CategorizeBusinessTripExpenseInput = {
  readonly amount?: InputMaybe<Scalars['Float']['input']>;
  readonly businessTripId: Scalars['UUID']['input'];
  readonly category?: InputMaybe<BusinessTripExpenseCategories>;
  readonly transactionId: Scalars['UUID']['input'];
};

/**  the input for categorizing into an existing business trip expense  */
export type CategorizeIntoExistingBusinessTripExpenseInput = {
  readonly amount?: InputMaybe<Scalars['Float']['input']>;
  readonly businessTripExpenseId: Scalars['UUID']['input'];
  readonly transactionId: Scalars['UUID']['input'];
};

/**  represent a complex type for grouped charge with ledger info, bank/card transactions and documents  */
export type Charge = {
  /**  calculated based on ledger record and transaction approvals  */
  readonly accountantApproval: AccountantStatus;
  /**  additional documents attached to the charge  */
  readonly additionalDocuments: ReadonlyArray<Document>;
  /**  is currency conversion  */
  readonly conversion?: Maybe<Scalars['Boolean']['output']>;
  /**  calculated counterparty details for the charge  */
  readonly counterparty?: Maybe<FinancialEntity>;
  readonly exchangeRates?: Maybe<ExchangeRates>;
  readonly id: Scalars['UUID']['output'];
  /**  is invoice currency different from the payment currency */
  readonly isInvoicePaymentDifferentCurrency?: Maybe<Scalars['Boolean']['output']>;
  /**  ledger records linked to the charge  */
  readonly ledger: Ledger;
  /**  metadata about the charge  */
  readonly metadata?: Maybe<ChargeMetadata>;
  /**  minimal debit date from linked transactions  */
  readonly minDebitDate?: Maybe<Scalars['DateTime']['output']>;
  /**  minimal date from linked documents  */
  readonly minDocumentsDate?: Maybe<Scalars['DateTime']['output']>;
  /**  minimal event date from linked transactions  */
  readonly minEventDate?: Maybe<Scalars['DateTime']['output']>;
  /**  list of misc expenses linked to transactions of the charge  */
  readonly miscExpenses: ReadonlyArray<MiscExpense>;
  /**  missing info suggestions data  */
  readonly missingInfoSuggestions?: Maybe<ChargeSuggestions>;
  /**  flag for optional VAT  */
  readonly optionalVAT?: Maybe<Scalars['Boolean']['output']>;
  /**  the financial entity that created the charge  */
  readonly owner: Business;
  /**  פחת, ציוד   */
  readonly property?: Maybe<Scalars['Boolean']['output']>;
  /**  is salary  */
  readonly salary?: Maybe<Scalars['Boolean']['output']>;
  /**  user customer tags  */
  readonly tags: ReadonlyArray<Tag>;
  readonly taxCategory?: Maybe<TaxCategory>;
  /**  the total amount of the charge  */
  readonly totalAmount?: Maybe<FinancialAmount>;
  /**  list of financial/bank transactions linked to the charge  */
  readonly transactions: ReadonlyArray<Transaction>;
  /**  user custom description  */
  readonly userDescription?: Maybe<Scalars['String']['output']>;
  /**  missing info validation data  */
  readonly validationData?: Maybe<ValidationData>;
  /**  calculated field based on the actual ledger records, optional because not all charges has VAT  */
  readonly vat?: Maybe<FinancialAmount>;
  /**  withholding tax  */
  readonly withholdingTax?: Maybe<FinancialAmount>;
  /**  the tax year in which the action took place  */
  readonly yearsOfRelevance?: Maybe<ReadonlyArray<YearOfRelevance>>;
};

/**  input variables for charge filtering  */
export type ChargeFilter = {
  readonly accountantStatus?: InputMaybe<ReadonlyArray<AccountantStatus>>;
  /**  filter by business trip (should be later in business trip module?)  */
  readonly businessTrip?: InputMaybe<Scalars['UUID']['input']>;
  /**  Include only charges including specific business  */
  readonly byBusinesses?: InputMaybe<ReadonlyArray<Scalars['UUID']['input']>>;
  /**  Include only charges related to specific financial accounts  */
  readonly byFinancialAccounts?: InputMaybe<ReadonlyArray<Scalars['UUID']['input']>>;
  /**  Include only charges related to specific owners financial entities  */
  readonly byOwners?: InputMaybe<ReadonlyArray<Scalars['UUID']['input']>>;
  /**  Include only charges with those tags  */
  readonly byTags?: InputMaybe<ReadonlyArray<Scalars['String']['input']>>;
  readonly chargesType?: InputMaybe<ChargeFilterType>;
  /**  Include only charges with any doc/transaction date occurred after this date  */
  readonly fromAnyDate?: InputMaybe<Scalars['TimelessDate']['input']>;
  /**  Include only charges with main date occurred after this date  */
  readonly fromDate?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly sortBy?: InputMaybe<ChargeSortBy>;
  /**  Include only charges with any doc/transaction date occurred before this date  */
  readonly toAnyDate?: InputMaybe<Scalars['TimelessDate']['input']>;
  /**  Include only charges with main date  occurred before this date  */
  readonly toDate?: InputMaybe<Scalars['TimelessDate']['input']>;
  /**  Include only charges that are not balances  */
  readonly unbalanced?: InputMaybe<Scalars['Boolean']['input']>;
  /**  Include only charges that doesn't have documents linked  */
  readonly withoutDocuments?: InputMaybe<Scalars['Boolean']['input']>;
  /**  Include only charges that doesn't have invoice document linked  */
  readonly withoutInvoice?: InputMaybe<Scalars['Boolean']['input']>;
  /**  Include only charges that doesn't have ledger records linked  */
  readonly withoutLedger?: InputMaybe<Scalars['Boolean']['input']>;
  /**  Include only charges that doesn't have receipt document linked  */
  readonly withoutReceipt?: InputMaybe<Scalars['Boolean']['input']>;
  /**  Include only charges that doesn't have transactions linked  */
  readonly withoutTransactions?: InputMaybe<Scalars['Boolean']['input']>;
};

/**  filter charges by type  */
export type ChargeFilterType =
  | 'ALL'
  | 'EXPENSE'
  | 'INCOME';

/**  represent charge's metadata */
export type ChargeMetadata = {
  readonly __typename?: 'ChargeMetadata';
  /**  when the initial charge was created from the first event we found  */
  readonly createdAt: Scalars['DateTime']['output'];
  readonly documentsCount: Scalars['Int']['output'];
  readonly invalidDocuments: Scalars['Boolean']['output'];
  readonly invalidLedger: LedgerValidationStatus;
  readonly invalidTransactions: Scalars['Boolean']['output'];
  readonly invoicesCount: Scalars['Int']['output'];
  readonly isSalary: Scalars['Boolean']['output'];
  readonly ledgerCount: Scalars['Int']['output'];
  readonly miscExpensesCount: Scalars['Int']['output'];
  readonly optionalBusinesses: ReadonlyArray<Scalars['String']['output']>;
  readonly receiptsCount: Scalars['Int']['output'];
  readonly transactionsCount: Scalars['Int']['output'];
  /**  when the charge was last updated  */
  readonly updatedAt: Scalars['DateTime']['output'];
};

/**  input variables for sorting charges  */
export type ChargeSortBy = {
  readonly asc?: InputMaybe<Scalars['Boolean']['input']>;
  readonly field: ChargeSortByField;
};

export { ChargeSortByField };

/**  represent charge suggestions for missing info  */
export type ChargeSuggestions = {
  readonly __typename?: 'ChargeSuggestions';
  readonly description?: Maybe<Scalars['String']['output']>;
  readonly tags: ReadonlyArray<Tag>;
};

/**  result type for charges with ledger changes  */
export type ChargesWithLedgerChangesResult = {
  readonly __typename?: 'ChargesWithLedgerChangesResult';
  readonly charge?: Maybe<Charge>;
  readonly progress: Scalars['Float']['output'];
};

/**  common charge  */
export type CommonCharge = Charge & {
  readonly __typename?: 'CommonCharge';
  readonly accountantApproval: AccountantStatus;
  readonly additionalDocuments: ReadonlyArray<Document>;
  readonly conversion?: Maybe<Scalars['Boolean']['output']>;
  readonly counterparty?: Maybe<FinancialEntity>;
  /**  depreciation records  */
  readonly depreciationRecords: ReadonlyArray<DepreciationRecord>;
  readonly exchangeRates?: Maybe<ExchangeRates>;
  readonly id: Scalars['UUID']['output'];
  readonly isInvoicePaymentDifferentCurrency?: Maybe<Scalars['Boolean']['output']>;
  readonly ledger: Ledger;
  readonly metadata?: Maybe<ChargeMetadata>;
  readonly minDebitDate?: Maybe<Scalars['DateTime']['output']>;
  readonly minDocumentsDate?: Maybe<Scalars['DateTime']['output']>;
  readonly minEventDate?: Maybe<Scalars['DateTime']['output']>;
  readonly miscExpenses: ReadonlyArray<MiscExpense>;
  readonly missingInfoSuggestions?: Maybe<ChargeSuggestions>;
  readonly optionalVAT?: Maybe<Scalars['Boolean']['output']>;
  readonly owner: Business;
  readonly property?: Maybe<Scalars['Boolean']['output']>;
  readonly salary?: Maybe<Scalars['Boolean']['output']>;
  readonly tags: ReadonlyArray<Tag>;
  readonly taxCategory?: Maybe<TaxCategory>;
  readonly totalAmount?: Maybe<FinancialAmount>;
  readonly transactions: ReadonlyArray<Transaction>;
  readonly userDescription?: Maybe<Scalars['String']['output']>;
  readonly validationData?: Maybe<ValidationData>;
  readonly vat?: Maybe<FinancialAmount>;
  readonly withholdingTax?: Maybe<FinancialAmount>;
  readonly yearsOfRelevance?: Maybe<ReadonlyArray<YearOfRelevance>>;
};

/**  common type of errors */
export type CommonError = Error & {
  readonly __typename?: 'CommonError';
  readonly message: Scalars['String']['output'];
};

/**  temp type until DB supports transactions differentiation  */
export type CommonTransaction = Transaction & {
  readonly __typename?: 'CommonTransaction';
  readonly account: FinancialAccount;
  readonly amount: FinancialAmount;
  readonly balance: FinancialAmount;
  readonly chargeId: Scalars['UUID']['output'];
  readonly counterparty?: Maybe<FinancialEntity>;
  readonly createdAt: Scalars['DateTime']['output'];
  readonly cryptoExchangeRate?: Maybe<ConversionRate>;
  readonly debitExchangeRates?: Maybe<ExchangeRates>;
  readonly direction: TransactionDirection;
  readonly effectiveDate?: Maybe<Scalars['TimelessDate']['output']>;
  readonly eventDate: Scalars['TimelessDate']['output'];
  readonly eventExchangeRates?: Maybe<ExchangeRates>;
  readonly exactEffectiveDate?: Maybe<Scalars['DateTime']['output']>;
  readonly id: Scalars['UUID']['output'];
  readonly isFee?: Maybe<Scalars['Boolean']['output']>;
  readonly missingInfoSuggestions?: Maybe<TransactionSuggestions>;
  readonly referenceId: Scalars['String']['output'];
  readonly referenceKey?: Maybe<Scalars['String']['output']>;
  readonly sourceDescription: Scalars['String']['output'];
  readonly sourceEffectiveDate?: Maybe<Scalars['TimelessDate']['output']>;
  readonly updatedAt: Scalars['DateTime']['output'];
};

/**  charge with conversion transactions  */
export type ConversionCharge = Charge & {
  readonly __typename?: 'ConversionCharge';
  readonly accountantApproval: AccountantStatus;
  readonly additionalDocuments: ReadonlyArray<Document>;
  readonly conversion?: Maybe<Scalars['Boolean']['output']>;
  readonly counterparty?: Maybe<FinancialEntity>;
  readonly eventRate?: Maybe<ConversionRate>;
  readonly exchangeRates?: Maybe<ExchangeRates>;
  readonly id: Scalars['UUID']['output'];
  readonly isInvoicePaymentDifferentCurrency?: Maybe<Scalars['Boolean']['output']>;
  readonly ledger: Ledger;
  readonly metadata?: Maybe<ChargeMetadata>;
  readonly minDebitDate?: Maybe<Scalars['DateTime']['output']>;
  readonly minDocumentsDate?: Maybe<Scalars['DateTime']['output']>;
  readonly minEventDate?: Maybe<Scalars['DateTime']['output']>;
  readonly miscExpenses: ReadonlyArray<MiscExpense>;
  readonly missingInfoSuggestions?: Maybe<ChargeSuggestions>;
  readonly officialRate?: Maybe<ConversionRate>;
  readonly optionalVAT?: Maybe<Scalars['Boolean']['output']>;
  readonly owner: Business;
  readonly property?: Maybe<Scalars['Boolean']['output']>;
  readonly salary?: Maybe<Scalars['Boolean']['output']>;
  readonly tags: ReadonlyArray<Tag>;
  readonly taxCategory?: Maybe<TaxCategory>;
  readonly totalAmount?: Maybe<FinancialAmount>;
  readonly transactions: ReadonlyArray<Transaction>;
  readonly userDescription?: Maybe<Scalars['String']['output']>;
  readonly validationData?: Maybe<ValidationData>;
  readonly vat?: Maybe<FinancialAmount>;
  readonly withholdingTax?: Maybe<FinancialAmount>;
  readonly yearsOfRelevance?: Maybe<ReadonlyArray<YearOfRelevance>>;
};

/**  represent exchange rate between two currencies  */
export type ConversionRate = {
  readonly __typename?: 'ConversionRate';
  readonly from: Currency;
  readonly rate: Scalars['Float']['output'];
  readonly to: Currency;
};

/**  המרה  */
export type ConversionTransaction = Transaction & {
  readonly __typename?: 'ConversionTransaction';
  readonly account: FinancialAccount;
  readonly amount: FinancialAmount;
  readonly balance: FinancialAmount;
  /**  המרה של הבנק  */
  readonly bankRate: Scalars['Rate']['output'];
  readonly chargeId: Scalars['UUID']['output'];
  readonly counterparty?: Maybe<FinancialEntity>;
  readonly createdAt: Scalars['DateTime']['output'];
  readonly cryptoExchangeRate?: Maybe<ConversionRate>;
  readonly debitExchangeRates?: Maybe<ExchangeRates>;
  readonly direction: TransactionDirection;
  readonly effectiveDate: Scalars['TimelessDate']['output'];
  readonly eventDate: Scalars['TimelessDate']['output'];
  readonly eventExchangeRates?: Maybe<ExchangeRates>;
  readonly exactEffectiveDate?: Maybe<Scalars['DateTime']['output']>;
  readonly id: Scalars['UUID']['output'];
  readonly isFee?: Maybe<Scalars['Boolean']['output']>;
  readonly missingInfoSuggestions?: Maybe<TransactionSuggestions>;
  /**  בנק ישראל  */
  readonly officialRateToLocal?: Maybe<Scalars['Rate']['output']>;
  readonly referenceId: Scalars['String']['output'];
  readonly referenceKey?: Maybe<Scalars['String']['output']>;
  readonly sourceDescription: Scalars['String']['output'];
  readonly sourceEffectiveDate?: Maybe<Scalars['TimelessDate']['output']>;
  readonly type: ConversionTransactionType;
  readonly updatedAt: Scalars['DateTime']['output'];
};

/**  Type pf conversion transaction  */
export type ConversionTransactionType =
  /**  מכירה  */
  | 'BASE'
  /**  קניה  */
  | 'QUOTE';

/**  Corporate tax variables  */
export type CorporateTax = {
  readonly __typename?: 'CorporateTax';
  readonly corporateId: Scalars['UUID']['output'];
  readonly date: Scalars['TimelessDate']['output'];
  readonly id: Scalars['ID']['output'];
  readonly taxRate: Scalars['Float']['output'];
};

/**  Corporate tax rule  */
export type CorporateTaxRule = {
  readonly __typename?: 'CorporateTaxRule';
  readonly id: Scalars['ID']['output'];
  readonly isCompliant: Scalars['Boolean']['output'];
  readonly percentage: CorporateTaxRulePercentage;
  readonly rule: Scalars['String']['output'];
};

/**  Corporate tax rule percentage  */
export type CorporateTaxRulePercentage = {
  readonly __typename?: 'CorporateTaxRulePercentage';
  readonly formatted: Scalars['String']['output'];
  readonly value: Scalars['Float']['output'];
};

/**  result type for corporateTaxReport  */
export type CorporateTaxRulingComplianceReport = {
  readonly __typename?: 'CorporateTaxRulingComplianceReport';
  readonly businessTripRndExpenses: FinancialAmount;
  readonly differences: CorporateTaxRulingComplianceReportDifferences;
  readonly foreignDevelopmentExpenses: FinancialAmount;
  readonly foreignDevelopmentRelativeToRnd: CorporateTaxRule;
  readonly id: Scalars['ID']['output'];
  readonly localDevelopmentExpenses: FinancialAmount;
  readonly localDevelopmentRelativeToRnd: CorporateTaxRule;
  readonly researchAndDevelopmentExpenses: FinancialAmount;
  readonly rndRelativeToIncome: CorporateTaxRule;
  readonly totalIncome: FinancialAmount;
  readonly year: Scalars['Int']['output'];
};

/**  Differences between the report info and the generated ledger suggested info  */
export type CorporateTaxRulingComplianceReportDifferences = {
  readonly __typename?: 'CorporateTaxRulingComplianceReportDifferences';
  readonly businessTripRndExpenses?: Maybe<FinancialAmount>;
  readonly foreignDevelopmentExpenses?: Maybe<FinancialAmount>;
  readonly foreignDevelopmentRelativeToRnd?: Maybe<CorporateTaxRule>;
  readonly id: Scalars['ID']['output'];
  readonly localDevelopmentExpenses?: Maybe<FinancialAmount>;
  readonly localDevelopmentRelativeToRnd?: Maybe<CorporateTaxRule>;
  readonly researchAndDevelopmentExpenses?: Maybe<FinancialAmount>;
  readonly rndRelativeToIncome?: Maybe<CorporateTaxRule>;
  readonly totalIncome?: Maybe<FinancialAmount>;
};

/**  a country  */
export type Country = {
  readonly __typename?: 'Country';
  readonly code: Scalars['String']['output'];
  readonly id: Scalars['ID']['output'];
  readonly name: Scalars['String']['output'];
};

/**  Credit invoice document - חשבונית זיכוי  */
export type CreditInvoice = Document & FinancialDocument & Linkable & {
  readonly __typename?: 'CreditInvoice';
  readonly amount?: Maybe<FinancialAmount>;
  readonly charge?: Maybe<Charge>;
  readonly creditor?: Maybe<FinancialEntity>;
  readonly date?: Maybe<Scalars['TimelessDate']['output']>;
  readonly debtor?: Maybe<FinancialEntity>;
  readonly documentType?: Maybe<DocumentType>;
  readonly file?: Maybe<Scalars['URL']['output']>;
  readonly id: Scalars['UUID']['output'];
  readonly image?: Maybe<Scalars['URL']['output']>;
  readonly isReviewed?: Maybe<Scalars['Boolean']['output']>;
  readonly missingInfoSuggestions?: Maybe<DocumentSuggestions>;
  readonly noVatAmount?: Maybe<Scalars['Float']['output']>;
  readonly serialNumber?: Maybe<Scalars['String']['output']>;
  readonly vat?: Maybe<FinancialAmount>;
  readonly vatReportDateOverride?: Maybe<Scalars['TimelessDate']['output']>;
};

/**  charge of creditcard over bank account  */
export type CreditcardBankCharge = Charge & {
  readonly __typename?: 'CreditcardBankCharge';
  readonly accountantApproval: AccountantStatus;
  readonly additionalDocuments: ReadonlyArray<Document>;
  readonly conversion?: Maybe<Scalars['Boolean']['output']>;
  readonly counterparty?: Maybe<FinancialEntity>;
  readonly creditCardTransactions: ReadonlyArray<Transaction>;
  readonly exchangeRates?: Maybe<ExchangeRates>;
  readonly id: Scalars['UUID']['output'];
  readonly isInvoicePaymentDifferentCurrency?: Maybe<Scalars['Boolean']['output']>;
  readonly ledger: Ledger;
  readonly metadata?: Maybe<ChargeMetadata>;
  readonly minDebitDate?: Maybe<Scalars['DateTime']['output']>;
  readonly minDocumentsDate?: Maybe<Scalars['DateTime']['output']>;
  readonly minEventDate?: Maybe<Scalars['DateTime']['output']>;
  readonly miscExpenses: ReadonlyArray<MiscExpense>;
  readonly missingInfoSuggestions?: Maybe<ChargeSuggestions>;
  readonly optionalVAT?: Maybe<Scalars['Boolean']['output']>;
  readonly owner: Business;
  readonly property?: Maybe<Scalars['Boolean']['output']>;
  readonly salary?: Maybe<Scalars['Boolean']['output']>;
  readonly tags: ReadonlyArray<Tag>;
  readonly taxCategory?: Maybe<TaxCategory>;
  readonly totalAmount?: Maybe<FinancialAmount>;
  readonly transactions: ReadonlyArray<Transaction>;
  readonly userDescription?: Maybe<Scalars['String']['output']>;
  readonly validCreditCardAmount: Scalars['Boolean']['output'];
  readonly validationData?: Maybe<ValidationData>;
  readonly vat?: Maybe<FinancialAmount>;
  readonly withholdingTax?: Maybe<FinancialAmount>;
  readonly yearsOfRelevance?: Maybe<ReadonlyArray<YearOfRelevance>>;
};

/**  represent a single credit card  */
export type CryptoWalletFinancialAccount = FinancialAccount & {
  readonly __typename?: 'CryptoWalletFinancialAccount';
  readonly charges: ReadonlyArray<Charge>;
  readonly id: Scalars['UUID']['output'];
  readonly name: Scalars['String']['output'];
  /**  the external identifier of the wallet  */
  readonly number: Scalars['String']['output'];
  readonly type: Scalars['String']['output'];
};


/**  represent a single credit card  */
export type CryptoWalletFinancialAccountChargesArgs = {
  filter?: InputMaybe<ChargeFilter>;
};

export { Currency };

/**  a date range  */
export type DateRange = {
  readonly __typename?: 'DateRange';
  readonly end: Scalars['TimelessDate']['output'];
  readonly start: Scalars['TimelessDate']['output'];
};

/**  the input for removing a business trip attendee  */
export type DeleteBusinessTripAttendeeInput = {
  readonly attendeeId: Scalars['UUID']['input'];
  readonly businessTripId: Scalars['UUID']['input'];
};

/**  represent a category of depreciation  */
export type DepreciationCategory = {
  readonly __typename?: 'DepreciationCategory';
  readonly id: Scalars['UUID']['output'];
  readonly name: Scalars['String']['output'];
  readonly percentage: Scalars['Float']['output'];
};

/**  represent a depreciation record for a charge */
export type DepreciationRecord = {
  readonly __typename?: 'DepreciationRecord';
  readonly activationDate: Scalars['TimelessDate']['output'];
  readonly amount: FinancialAmount;
  readonly category: DepreciationCategory;
  readonly charge: Charge;
  readonly chargeId: Scalars['UUID']['output'];
  readonly id: Scalars['UUID']['output'];
  readonly type?: Maybe<DepreciationType>;
};

/**  depreciation type  */
export type DepreciationType =
  | 'GENERAL_AND_MANAGEMENT'
  | 'MARKETING'
  | 'RESEARCH_AND_DEVELOPMENT';

/**  charge of dividends  */
export type DividendCharge = Charge & {
  readonly __typename?: 'DividendCharge';
  readonly accountantApproval: AccountantStatus;
  readonly additionalDocuments: ReadonlyArray<Document>;
  readonly conversion?: Maybe<Scalars['Boolean']['output']>;
  readonly counterparty?: Maybe<FinancialEntity>;
  readonly exchangeRates?: Maybe<ExchangeRates>;
  readonly id: Scalars['UUID']['output'];
  readonly isInvoicePaymentDifferentCurrency?: Maybe<Scalars['Boolean']['output']>;
  readonly ledger: Ledger;
  readonly metadata?: Maybe<ChargeMetadata>;
  readonly minDebitDate?: Maybe<Scalars['DateTime']['output']>;
  readonly minDocumentsDate?: Maybe<Scalars['DateTime']['output']>;
  readonly minEventDate?: Maybe<Scalars['DateTime']['output']>;
  readonly miscExpenses: ReadonlyArray<MiscExpense>;
  readonly missingInfoSuggestions?: Maybe<ChargeSuggestions>;
  readonly optionalVAT?: Maybe<Scalars['Boolean']['output']>;
  readonly owner: Business;
  readonly property?: Maybe<Scalars['Boolean']['output']>;
  readonly salary?: Maybe<Scalars['Boolean']['output']>;
  readonly tags: ReadonlyArray<Tag>;
  readonly taxCategory?: Maybe<TaxCategory>;
  readonly totalAmount?: Maybe<FinancialAmount>;
  readonly transactions: ReadonlyArray<Transaction>;
  readonly userDescription?: Maybe<Scalars['String']['output']>;
  readonly validationData?: Maybe<ValidationData>;
  readonly vat?: Maybe<FinancialAmount>;
  readonly withholdingTax?: Maybe<FinancialAmount>;
  readonly yearsOfRelevance?: Maybe<ReadonlyArray<YearOfRelevance>>;
};

/**  represent a generic document with identifier and a URL  */
export type Document = {
  readonly charge?: Maybe<Charge>;
  /**  the specific type of the document */
  readonly documentType?: Maybe<DocumentType>;
  /**  link to original file gmail, pdf  */
  readonly file?: Maybe<Scalars['URL']['output']>;
  readonly id: Scalars['UUID']['output'];
  /**  previewable image  */
  readonly image?: Maybe<Scalars['URL']['output']>;
  readonly isReviewed?: Maybe<Scalars['Boolean']['output']>;
};

/**  represent document suggestions for missing info  */
export type DocumentSuggestions = {
  readonly __typename?: 'DocumentSuggestions';
  /**  The document amount  */
  readonly amount?: Maybe<FinancialAmount>;
  /**  The counter-side of the document (opposite to it's owner)  */
  readonly counterparty?: Maybe<FinancialEntity>;
  /**  The document direction (income or expense)  */
  readonly isIncome?: Maybe<Scalars['Boolean']['output']>;
  /**  The owner of the document  */
  readonly owner?: Maybe<FinancialEntity>;
};

export { DocumentType };

/**  input variables for documents filtering  */
export type DocumentsFilters = {
  readonly businessIDs?: InputMaybe<ReadonlyArray<Scalars['UUID']['input']>>;
  readonly fromDate?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly ownerIDs?: InputMaybe<ReadonlyArray<Scalars['UUID']['input']>>;
  readonly toDate?: InputMaybe<Scalars['TimelessDate']['input']>;
  /**  Include only documents without matching transactions  */
  readonly unmatched?: InputMaybe<Scalars['Boolean']['input']>;
};

/**  dynamic report data  */
export type DynamicReportInfo = {
  readonly __typename?: 'DynamicReportInfo';
  readonly created: Scalars['DateTime']['output'];
  readonly id: Scalars['ID']['output'];
  readonly name: Scalars['String']['output'];
  readonly template: ReadonlyArray<DynamicReportNode>;
  readonly updated: Scalars['DateTime']['output'];
};

/**  a single node of dynamic report template  */
export type DynamicReportNode = {
  readonly __typename?: 'DynamicReportNode';
  readonly data: DynamicReportNodeData;
  readonly droppable: Scalars['Boolean']['output'];
  readonly id: Scalars['ID']['output'];
  readonly parent: Scalars['String']['output'];
  readonly text: Scalars['String']['output'];
};

/**  data of a single node of dynamic report template  */
export type DynamicReportNodeData = {
  readonly __typename?: 'DynamicReportNodeData';
  readonly descendantFinancialEntities?: Maybe<ReadonlyArray<Scalars['UUID']['output']>>;
  readonly descendantSortCodes?: Maybe<ReadonlyArray<Scalars['Int']['output']>>;
  readonly hebrewText?: Maybe<Scalars['String']['output']>;
  readonly isOpen: Scalars['Boolean']['output'];
  readonly mergedSortCodes?: Maybe<ReadonlyArray<Scalars['Int']['output']>>;
};

/**  represent employee record */
export type Employee = {
  readonly __typename?: 'Employee';
  readonly id: Scalars['UUID']['output'];
  readonly name: Scalars['String']['output'];
};

/**  basic structure of error  */
export type Error = {
  readonly message: Scalars['String']['output'];
};

/**  represent a financial amount in a specific currency  */
export type ExchangeRates = {
  readonly __typename?: 'ExchangeRates';
  readonly cad?: Maybe<FinancialAmount>;
  readonly date: Scalars['TimelessDate']['output'];
  readonly eur?: Maybe<FinancialAmount>;
  readonly gbp?: Maybe<FinancialAmount>;
  readonly usd?: Maybe<FinancialAmount>;
};

/**  Represent something external that we scrape, like bank or card  */
export type FinancialAccount = {
  readonly charges: ReadonlyArray<Charge>;
  readonly id: Scalars['UUID']['output'];
  /**  the name of the account */
  readonly name: Scalars['String']['output'];
  /**  the general type of the account */
  readonly type: Scalars['String']['output'];
};


/**  Represent something external that we scrape, like bank or card  */
export type FinancialAccountChargesArgs = {
  filter?: InputMaybe<ChargeFilter>;
};

/**  Represent financial amount  */
export type FinancialAmount = {
  readonly __typename?: 'FinancialAmount';
  /**  currency of the amount  */
  readonly currency: Currency;
  /**  formatted value with the currency symbol, like: 10$  */
  readonly formatted: Scalars['String']['output'];
  /**  the raw amount, for example: 19.99  */
  readonly raw: Scalars['Float']['output'];
};

/**  input variables for updateCharge.FinancialAmount */
export type FinancialAmountInput = {
  readonly currency: Currency;
  readonly raw: Scalars['Float']['input'];
};

/**  financial charge  */
export type FinancialCharge = Charge & {
  readonly __typename?: 'FinancialCharge';
  readonly accountantApproval: AccountantStatus;
  readonly additionalDocuments: ReadonlyArray<Document>;
  readonly conversion?: Maybe<Scalars['Boolean']['output']>;
  readonly counterparty?: Maybe<FinancialEntity>;
  readonly exchangeRates?: Maybe<ExchangeRates>;
  readonly id: Scalars['UUID']['output'];
  readonly isInvoicePaymentDifferentCurrency?: Maybe<Scalars['Boolean']['output']>;
  readonly ledger: Ledger;
  readonly metadata?: Maybe<ChargeMetadata>;
  readonly minDebitDate?: Maybe<Scalars['DateTime']['output']>;
  readonly minDocumentsDate?: Maybe<Scalars['DateTime']['output']>;
  readonly minEventDate?: Maybe<Scalars['DateTime']['output']>;
  readonly miscExpenses: ReadonlyArray<MiscExpense>;
  readonly missingInfoSuggestions?: Maybe<ChargeSuggestions>;
  readonly optionalVAT?: Maybe<Scalars['Boolean']['output']>;
  readonly owner: Business;
  readonly property?: Maybe<Scalars['Boolean']['output']>;
  readonly salary?: Maybe<Scalars['Boolean']['output']>;
  readonly tags: ReadonlyArray<Tag>;
  readonly taxCategory?: Maybe<TaxCategory>;
  readonly totalAmount?: Maybe<FinancialAmount>;
  readonly transactions: ReadonlyArray<Transaction>;
  readonly userDescription?: Maybe<Scalars['String']['output']>;
  readonly validationData?: Maybe<ValidationData>;
  readonly vat?: Maybe<FinancialAmount>;
  readonly withholdingTax?: Maybe<FinancialAmount>;
  readonly yearsOfRelevance?: Maybe<ReadonlyArray<YearOfRelevance>>;
};

/**  represent a financial document  */
export type FinancialDocument = {
  readonly amount?: Maybe<FinancialAmount>;
  readonly charge?: Maybe<Charge>;
  readonly creditor?: Maybe<FinancialEntity>;
  readonly date?: Maybe<Scalars['TimelessDate']['output']>;
  readonly debtor?: Maybe<FinancialEntity>;
  readonly documentType?: Maybe<DocumentType>;
  readonly file?: Maybe<Scalars['URL']['output']>;
  readonly id: Scalars['UUID']['output'];
  readonly image?: Maybe<Scalars['URL']['output']>;
  readonly isReviewed?: Maybe<Scalars['Boolean']['output']>;
  /**  missing info suggestions data  */
  readonly missingInfoSuggestions?: Maybe<DocumentSuggestions>;
  readonly noVatAmount?: Maybe<Scalars['Float']['output']>;
  readonly serialNumber?: Maybe<Scalars['String']['output']>;
  readonly vat?: Maybe<FinancialAmount>;
  readonly vatReportDateOverride?: Maybe<Scalars['TimelessDate']['output']>;
};

/**  represent a financial entity of any type, including businesses, tax categories, etc.  */
export type FinancialEntity = {
  readonly id: Scalars['UUID']['output'];
  readonly name: Scalars['String']['output'];
  readonly sortCode?: Maybe<SortCode>;
};

/**  represent financial entity type  */
export type FinancialEntityType =
  | 'BUSINESS'
  | 'TAX_CATEGORY';

/**  Represent financial rounded amount with Int values  */
export type FinancialIntAmount = {
  readonly __typename?: 'FinancialIntAmount';
  /**  currency of the amount  */
  readonly currency: Currency;
  /**  formatted value with the currency symbol, like: 10$  */
  readonly formatted: Scalars['String']['output'];
  /**  the raw amount, for example: 19  */
  readonly raw: Scalars['Int']['output'];
};

/**  result type for flagForeignFeeTransactions  */
export type FlagForeignFeeTransactionsResult = {
  readonly __typename?: 'FlagForeignFeeTransactionsResult';
  readonly errors?: Maybe<ReadonlyArray<Scalars['String']['output']>>;
  readonly success: Scalars['Boolean']['output'];
  readonly transactions?: Maybe<ReadonlyArray<Transaction>>;
};

/**  represent flight classes  */
export type FlightClass =
  | 'BUSINESS'
  | 'ECONOMY'
  | 'FIRST_CLASS'
  | 'PREMIUM_ECONOMY';

/**  summary of foreign currency business transactions  */
export type ForeignCurrencySum = {
  readonly __typename?: 'ForeignCurrencySum';
  readonly credit: FinancialAmount;
  readonly currency: Currency;
  readonly debit: FinancialAmount;
  readonly total: FinancialAmount;
};

/**  fund entity prototype  */
export type Fund = {
  readonly id: Scalars['UUID']['output'];
  readonly name: Scalars['String']['output'];
};

/**  result type for generateMonthlyClientDocuments */
export type GenerateMonthlyClientDocumentsResult = {
  readonly __typename?: 'GenerateMonthlyClientDocumentsResult';
  readonly errors?: Maybe<ReadonlyArray<Scalars['String']['output']>>;
  readonly success: Scalars['Boolean']['output'];
};

/**  result type for ledger records  */
export type GeneratedLedgerRecords = CommonError | Ledger;

/**  income chart information  */
export type IncomeExpenseChart = {
  readonly __typename?: 'IncomeExpenseChart';
  readonly currency: Currency;
  readonly fromDate: Scalars['TimelessDate']['output'];
  readonly monthlyData: ReadonlyArray<IncomeExpenseChartMonthData>;
  readonly toDate: Scalars['TimelessDate']['output'];
};

/**  input variables for incomeExpenseChart filters  */
export type IncomeExpenseChartFilters = {
  readonly currency?: InputMaybe<Currency>;
  readonly fromDate: Scalars['TimelessDate']['input'];
  readonly toDate: Scalars['TimelessDate']['input'];
};

/**  income chart month information  */
export type IncomeExpenseChartMonthData = {
  readonly __typename?: 'IncomeExpenseChartMonthData';
  readonly balance: FinancialAmount;
  readonly date: Scalars['TimelessDate']['output'];
  readonly expense: FinancialAmount;
  readonly income: FinancialAmount;
};

/**  the input for adding an attendee to a business trip  */
export type InsertBusinessTripAttendeeInput = {
  readonly arrivalDate?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly attendeeId: Scalars['UUID']['input'];
  readonly businessTripId: Scalars['UUID']['input'];
  readonly departureDate?: InputMaybe<Scalars['TimelessDate']['input']>;
};

/**  the input for creating a business trip  */
export type InsertBusinessTripInput = {
  readonly destinationCode?: InputMaybe<Scalars['String']['input']>;
  readonly fromDate?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly name: Scalars['String']['input'];
  readonly toDate?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly tripPurpose?: InputMaybe<Scalars['String']['input']>;
};

/**  input variables for insertDepreciationCategory  */
export type InsertDepreciationCategoryInput = {
  readonly name: Scalars['String']['input'];
  readonly percentage: Scalars['Float']['input'];
};

/**  result type for insertDepreciationCategory  */
export type InsertDepreciationCategoryResult = CommonError | DepreciationCategory;

/**  input variables for insertDepreciationRecord  */
export type InsertDepreciationRecordInput = {
  readonly activationDate: Scalars['TimelessDate']['input'];
  readonly amount?: InputMaybe<Scalars['Float']['input']>;
  readonly categoryId: Scalars['UUID']['input'];
  readonly chargeId: Scalars['UUID']['input'];
  readonly currency?: InputMaybe<Currency>;
  readonly type?: InputMaybe<DepreciationType>;
};

/**  result type for insertDepreciationRecord  */
export type InsertDepreciationRecordResult = CommonError | DepreciationRecord;

/**  input variables for insertDocument  */
export type InsertDocumentInput = {
  readonly amount?: InputMaybe<FinancialAmountInput>;
  readonly chargeId?: InputMaybe<Scalars['UUID']['input']>;
  readonly creditorId?: InputMaybe<Scalars['UUID']['input']>;
  readonly date?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly debtorId?: InputMaybe<Scalars['UUID']['input']>;
  readonly documentType?: InputMaybe<DocumentType>;
  readonly file?: InputMaybe<Scalars['URL']['input']>;
  readonly image?: InputMaybe<Scalars['URL']['input']>;
  readonly noVatAmount?: InputMaybe<Scalars['Float']['input']>;
  readonly serialNumber?: InputMaybe<Scalars['String']['input']>;
  readonly vat?: InputMaybe<FinancialAmountInput>;
  readonly vatReportDateOverride?: InputMaybe<Scalars['TimelessDate']['input']>;
};

/**  result type for insertDocument  */
export type InsertDocumentResult = CommonError | InsertDocumentSuccessfulResult;

/**  result type for insertDocument */
export type InsertDocumentSuccessfulResult = {
  readonly __typename?: 'InsertDocumentSuccessfulResult';
  readonly document?: Maybe<Document>;
};

/**  input variables for insertMiscExpense  */
export type InsertMiscExpenseInput = {
  readonly amount: Scalars['Float']['input'];
  readonly chargeId: Scalars['UUID']['input'];
  readonly creditorId: Scalars['UUID']['input'];
  readonly currency: Currency;
  readonly debtorId: Scalars['UUID']['input'];
  readonly description?: InputMaybe<Scalars['String']['input']>;
  readonly invoiceDate: Scalars['TimelessDate']['input'];
  readonly valueDate: Scalars['DateTime']['input'];
};

/**  input for insertNewBusiness  */
export type InsertNewBusinessInput = {
  readonly address?: InputMaybe<Scalars['String']['input']>;
  readonly country?: InputMaybe<Scalars['String']['input']>;
  readonly email?: InputMaybe<Scalars['String']['input']>;
  readonly exemptDealer?: InputMaybe<Scalars['Boolean']['input']>;
  readonly governmentId?: InputMaybe<Scalars['String']['input']>;
  readonly hebrewName?: InputMaybe<Scalars['String']['input']>;
  readonly name: Scalars['String']['input'];
  readonly optionalVAT?: InputMaybe<Scalars['Boolean']['input']>;
  readonly phoneNumber?: InputMaybe<Scalars['String']['input']>;
  readonly sortCode?: InputMaybe<Scalars['Int']['input']>;
  readonly suggestions?: InputMaybe<SuggestionsInput>;
  readonly taxCategory?: InputMaybe<Scalars['UUID']['input']>;
  readonly website?: InputMaybe<Scalars['String']['input']>;
};

/**  result type for insertSalaryRecord  */
export type InsertSalaryRecordsResult = CommonError | InsertSalaryRecordsSuccessfulResult;

/**  result type for insertSalaryRecord */
export type InsertSalaryRecordsSuccessfulResult = {
  readonly __typename?: 'InsertSalaryRecordsSuccessfulResult';
  readonly salaryRecords: ReadonlyArray<Salary>;
};

/**  input for insertTaxCategory  */
export type InsertTaxCategoryInput = {
  readonly hashavshevetName?: InputMaybe<Scalars['String']['input']>;
  readonly name: Scalars['String']['input'];
  readonly sortCode?: InputMaybe<Scalars['Int']['input']>;
};

/**  charge of internal transfer  */
export type InternalTransferCharge = Charge & {
  readonly __typename?: 'InternalTransferCharge';
  readonly accountantApproval: AccountantStatus;
  readonly additionalDocuments: ReadonlyArray<Document>;
  readonly conversion?: Maybe<Scalars['Boolean']['output']>;
  readonly counterparty?: Maybe<FinancialEntity>;
  readonly exchangeRates?: Maybe<ExchangeRates>;
  readonly id: Scalars['UUID']['output'];
  readonly isInvoicePaymentDifferentCurrency?: Maybe<Scalars['Boolean']['output']>;
  readonly ledger: Ledger;
  readonly metadata?: Maybe<ChargeMetadata>;
  readonly minDebitDate?: Maybe<Scalars['DateTime']['output']>;
  readonly minDocumentsDate?: Maybe<Scalars['DateTime']['output']>;
  readonly minEventDate?: Maybe<Scalars['DateTime']['output']>;
  readonly miscExpenses: ReadonlyArray<MiscExpense>;
  readonly missingInfoSuggestions?: Maybe<ChargeSuggestions>;
  readonly optionalVAT?: Maybe<Scalars['Boolean']['output']>;
  readonly owner: Business;
  readonly property?: Maybe<Scalars['Boolean']['output']>;
  readonly salary?: Maybe<Scalars['Boolean']['output']>;
  readonly tags: ReadonlyArray<Tag>;
  readonly taxCategory?: Maybe<TaxCategory>;
  readonly totalAmount?: Maybe<FinancialAmount>;
  readonly transactions: ReadonlyArray<Transaction>;
  readonly userDescription?: Maybe<Scalars['String']['output']>;
  readonly validationData?: Maybe<ValidationData>;
  readonly vat?: Maybe<FinancialAmount>;
  readonly withholdingTax?: Maybe<FinancialAmount>;
  readonly yearsOfRelevance?: Maybe<ReadonlyArray<YearOfRelevance>>;
};

/**  invoice document  */
export type Invoice = Document & FinancialDocument & Linkable & {
  readonly __typename?: 'Invoice';
  readonly amount?: Maybe<FinancialAmount>;
  readonly charge?: Maybe<Charge>;
  readonly creditor?: Maybe<FinancialEntity>;
  readonly date?: Maybe<Scalars['TimelessDate']['output']>;
  readonly debtor?: Maybe<FinancialEntity>;
  readonly documentType?: Maybe<DocumentType>;
  readonly file?: Maybe<Scalars['URL']['output']>;
  readonly id: Scalars['UUID']['output'];
  readonly image?: Maybe<Scalars['URL']['output']>;
  readonly isReviewed?: Maybe<Scalars['Boolean']['output']>;
  readonly missingInfoSuggestions?: Maybe<DocumentSuggestions>;
  readonly noVatAmount?: Maybe<Scalars['Float']['output']>;
  readonly serialNumber?: Maybe<Scalars['String']['output']>;
  readonly vat?: Maybe<FinancialAmount>;
  readonly vatReportDateOverride?: Maybe<Scalars['TimelessDate']['output']>;
};

/**  Invoice receipt document - חשבונית מס קבלה  */
export type InvoiceReceipt = Document & FinancialDocument & Linkable & {
  readonly __typename?: 'InvoiceReceipt';
  readonly amount?: Maybe<FinancialAmount>;
  readonly charge?: Maybe<Charge>;
  readonly creditor?: Maybe<FinancialEntity>;
  readonly date?: Maybe<Scalars['TimelessDate']['output']>;
  readonly debtor?: Maybe<FinancialEntity>;
  readonly documentType?: Maybe<DocumentType>;
  readonly file?: Maybe<Scalars['URL']['output']>;
  readonly id: Scalars['UUID']['output'];
  readonly image?: Maybe<Scalars['URL']['output']>;
  readonly isReviewed?: Maybe<Scalars['Boolean']['output']>;
  readonly missingInfoSuggestions?: Maybe<DocumentSuggestions>;
  readonly noVatAmount?: Maybe<Scalars['Float']['output']>;
  readonly serialNumber?: Maybe<Scalars['String']['output']>;
  readonly vat?: Maybe<FinancialAmount>;
  readonly vatReportDateOverride?: Maybe<Scalars['TimelessDate']['output']>;
};

/**  array of ledger records linked to the charge  */
export type Ledger = {
  readonly __typename?: 'Ledger';
  readonly balance?: Maybe<LedgerBalanceInfo>;
  readonly records: ReadonlyArray<LedgerRecord>;
  readonly validate: LedgerValidation;
};


/**  array of ledger records linked to the charge  */
export type LedgerValidateArgs = {
  shouldInsertLedgerInNew?: InputMaybe<Scalars['Boolean']['input']>;
};

/**  info about ledger total balance  */
export type LedgerBalanceInfo = {
  readonly __typename?: 'LedgerBalanceInfo';
  readonly isBalanced: Scalars['Boolean']['output'];
  readonly unbalancedEntities: ReadonlyArray<LedgerBalanceUnbalancedEntity>;
};

/**  unbalanced entity over ledger records  */
export type LedgerBalanceUnbalancedEntity = {
  readonly __typename?: 'LedgerBalanceUnbalancedEntity';
  readonly balance: FinancialAmount;
  readonly entity: FinancialEntity;
};

/**  represent atomic movement of funds  */
export type LedgerRecord = {
  readonly __typename?: 'LedgerRecord';
  readonly creditAccount1?: Maybe<FinancialEntity>;
  readonly creditAccount2?: Maybe<FinancialEntity>;
  readonly creditAmount1?: Maybe<FinancialAmount>;
  readonly creditAmount2?: Maybe<FinancialAmount>;
  readonly debitAccount1?: Maybe<FinancialEntity>;
  readonly debitAccount2?: Maybe<FinancialEntity>;
  readonly debitAmount1?: Maybe<FinancialAmount>;
  readonly debitAmount2?: Maybe<FinancialAmount>;
  readonly description?: Maybe<Scalars['String']['output']>;
  readonly id: Scalars['UUID']['output'];
  readonly invoiceDate: Scalars['DateTime']['output'];
  readonly localCurrencyCreditAmount1: FinancialAmount;
  readonly localCurrencyCreditAmount2?: Maybe<FinancialAmount>;
  readonly localCurrencyDebitAmount1: FinancialAmount;
  readonly localCurrencyDebitAmount2?: Maybe<FinancialAmount>;
  readonly reference?: Maybe<Scalars['String']['output']>;
  readonly valueDate: Scalars['DateTime']['output'];
};

/**  ledger validation info */
export type LedgerValidation = {
  readonly __typename?: 'LedgerValidation';
  readonly differences: ReadonlyArray<LedgerRecord>;
  readonly errors: ReadonlyArray<Scalars['String']['output']>;
  readonly isValid: Scalars['Boolean']['output'];
  readonly matches: ReadonlyArray<Scalars['UUID']['output']>;
};

/**  represent charge's metadata ledger validation status  */
export type LedgerValidationStatus =
  | 'DIFF'
  | 'INVALID'
  | 'VALID';

/**  represent a link to an external file  */
export type Linkable = {
  readonly file?: Maybe<Scalars['URL']['output']>;
};

/**  Financial entity, identifier by ID, can be a company or individual  */
export type LtdFinancialEntity = Business & FinancialEntity & {
  readonly __typename?: 'LtdFinancialEntity';
  readonly accounts: ReadonlyArray<FinancialAccount>;
  readonly address?: Maybe<Scalars['String']['output']>;
  readonly charges: PaginatedCharges;
  readonly country: Scalars['String']['output'];
  readonly email?: Maybe<Scalars['String']['output']>;
  readonly exemptDealer?: Maybe<Scalars['Boolean']['output']>;
  readonly governmentId?: Maybe<Scalars['String']['output']>;
  readonly hebrewName?: Maybe<Scalars['String']['output']>;
  readonly id: Scalars['UUID']['output'];
  readonly name: Scalars['String']['output'];
  readonly optionalVAT?: Maybe<Scalars['Boolean']['output']>;
  readonly phoneNumber?: Maybe<Scalars['String']['output']>;
  readonly sortCode?: Maybe<SortCode>;
  readonly suggestions?: Maybe<Suggestions>;
  readonly taxCategory?: Maybe<TaxCategory>;
  readonly website?: Maybe<Scalars['String']['output']>;
};


/**  Financial entity, identifier by ID, can be a company or individual  */
export type LtdFinancialEntityChargesArgs = {
  filter?: InputMaybe<ChargeFilter>;
  limit?: InputMaybe<Scalars['Int']['input']>;
  page?: InputMaybe<Scalars['Int']['input']>;
};

/**  result type for mergeCharge  */
export type MergeChargeResult = CommonError | MergeChargeSuccessfulResult;

/**  successful result type for mergeCharge  */
export type MergeChargeSuccessfulResult = {
  readonly __typename?: 'MergeChargeSuccessfulResult';
  readonly charge: Charge;
};

/**  result type for mergeChargesByTransactionReference  */
export type MergeChargesByTransactionReferenceResult = {
  readonly __typename?: 'MergeChargesByTransactionReferenceResult';
  readonly charges?: Maybe<ReadonlyArray<Charge>>;
  readonly errors?: Maybe<ReadonlyArray<Scalars['String']['output']>>;
  readonly success: Scalars['Boolean']['output'];
};

/**  a misc expense   */
export type MiscExpense = {
  readonly __typename?: 'MiscExpense';
  readonly amount: FinancialAmount;
  readonly charge: Charge;
  readonly chargeId: Scalars['UUID']['output'];
  readonly creditor: FinancialEntity;
  readonly debtor: FinancialEntity;
  readonly description?: Maybe<Scalars['String']['output']>;
  readonly id: Scalars['UUID']['output'];
  readonly invoiceDate: Scalars['TimelessDate']['output'];
  readonly valueDate: Scalars['DateTime']['output'];
};

export { MissingChargeInfo };

/**  charge of monthly VAT payment  */
export type MonthlyVatCharge = Charge & {
  readonly __typename?: 'MonthlyVatCharge';
  readonly accountantApproval: AccountantStatus;
  readonly additionalDocuments: ReadonlyArray<Document>;
  readonly conversion?: Maybe<Scalars['Boolean']['output']>;
  readonly counterparty?: Maybe<FinancialEntity>;
  readonly exchangeRates?: Maybe<ExchangeRates>;
  readonly id: Scalars['UUID']['output'];
  readonly isInvoicePaymentDifferentCurrency?: Maybe<Scalars['Boolean']['output']>;
  readonly ledger: Ledger;
  readonly metadata?: Maybe<ChargeMetadata>;
  readonly minDebitDate?: Maybe<Scalars['DateTime']['output']>;
  readonly minDocumentsDate?: Maybe<Scalars['DateTime']['output']>;
  readonly minEventDate?: Maybe<Scalars['DateTime']['output']>;
  readonly miscExpenses: ReadonlyArray<MiscExpense>;
  readonly missingInfoSuggestions?: Maybe<ChargeSuggestions>;
  readonly optionalVAT?: Maybe<Scalars['Boolean']['output']>;
  readonly owner: Business;
  readonly property?: Maybe<Scalars['Boolean']['output']>;
  readonly salary?: Maybe<Scalars['Boolean']['output']>;
  readonly tags: ReadonlyArray<Tag>;
  readonly taxCategory?: Maybe<TaxCategory>;
  readonly totalAmount?: Maybe<FinancialAmount>;
  readonly transactions: ReadonlyArray<Transaction>;
  readonly userDescription?: Maybe<Scalars['String']['output']>;
  readonly validationData?: Maybe<ValidationData>;
  readonly vat?: Maybe<FinancialAmount>;
  readonly withholdingTax?: Maybe<FinancialAmount>;
  readonly yearsOfRelevance?: Maybe<ReadonlyArray<YearOfRelevance>>;
};

/**  mutation root  */
export type Mutation = {
  readonly __typename?: 'Mutation';
  readonly addBusinessTripAccommodationsExpense: Scalars['UUID']['output'];
  readonly addBusinessTripCarRentalExpense: Scalars['UUID']['output'];
  readonly addBusinessTripFlightsExpense: Scalars['UUID']['output'];
  readonly addBusinessTripOtherExpense: Scalars['UUID']['output'];
  readonly addBusinessTripTravelAndSubsistenceExpense: Scalars['UUID']['output'];
  readonly addTag: Scalars['Boolean']['output'];
  readonly batchGenerateBusinessesOutOfTransactions: ReadonlyArray<Business>;
  readonly batchUploadDocuments: ReadonlyArray<UploadDocumentResult>;
  readonly batchUploadDocumentsFromGoogleDrive: ReadonlyArray<UploadDocumentResult>;
  readonly categorizeBusinessTripExpense: Scalars['UUID']['output'];
  readonly categorizeIntoExistingBusinessTripExpense: Scalars['UUID']['output'];
  readonly creditShareholdersBusinessTripTravelAndSubsistence: ReadonlyArray<Scalars['UUID']['output']>;
  readonly deleteBusinessTripAttendee: Scalars['Boolean']['output'];
  readonly deleteBusinessTripExpense: Scalars['Boolean']['output'];
  readonly deleteCharge: Scalars['Boolean']['output'];
  readonly deleteDepreciationCategory: Scalars['Boolean']['output'];
  readonly deleteDepreciationRecord: Scalars['Boolean']['output'];
  readonly deleteDocument: Scalars['Boolean']['output'];
  readonly deleteDynamicReportTemplate: Scalars['String']['output'];
  readonly deleteMiscExpense: Scalars['Boolean']['output'];
  readonly deleteTag: Scalars['Boolean']['output'];
  readonly fetchIncomeDocuments: ReadonlyArray<Document>;
  readonly flagForeignFeeTransactions: FlagForeignFeeTransactionsResult;
  readonly generateBankDepositsRevaluationCharge: FinancialCharge;
  readonly generateDepreciationCharge: FinancialCharge;
  readonly generateMonthlyClientDocuments: GenerateMonthlyClientDocumentsResult;
  readonly generateRecoveryReserveCharge: FinancialCharge;
  readonly generateRevaluationCharge: FinancialCharge;
  readonly generateTaxExpensesCharge: FinancialCharge;
  readonly generateVacationReserveCharge: FinancialCharge;
  readonly insertBusinessTrip: Scalars['UUID']['output'];
  readonly insertBusinessTripAttendee: Scalars['UUID']['output'];
  readonly insertDepreciationCategory: InsertDepreciationCategoryResult;
  readonly insertDepreciationRecord: InsertDepreciationRecordResult;
  readonly insertDocument: InsertDocumentResult;
  readonly insertDynamicReportTemplate: DynamicReportInfo;
  readonly insertMiscExpense: MiscExpense;
  readonly insertNewBusiness: UpdateBusinessResponse;
  readonly insertOrUpdateSalaryRecords: InsertSalaryRecordsResult;
  readonly insertSalaryRecords: InsertSalaryRecordsResult;
  readonly insertSalaryRecordsFromFile: Scalars['Boolean']['output'];
  readonly insertTaxCategory: TaxCategory;
  readonly mergeBusinesses: Business;
  readonly mergeCharges: MergeChargeResult;
  readonly mergeChargesByTransactionReference: MergeChargesByTransactionReferenceResult;
  readonly pong?: Maybe<Scalars['Boolean']['output']>;
  readonly regenerateLedgerRecords: GeneratedLedgerRecords;
  readonly uncategorizePartialBusinessTripExpense: Scalars['Boolean']['output'];
  readonly updateBusiness: UpdateBusinessResponse;
  readonly updateBusinessTrip: Scalars['UUID']['output'];
  readonly updateBusinessTripAccommodationsExpense: Scalars['UUID']['output'];
  readonly updateBusinessTripAccountantApproval: AccountantStatus;
  readonly updateBusinessTripAttendee: Scalars['UUID']['output'];
  readonly updateBusinessTripCarRentalExpense: Scalars['UUID']['output'];
  readonly updateBusinessTripFlightsExpense: Scalars['UUID']['output'];
  readonly updateBusinessTripOtherExpense: Scalars['UUID']['output'];
  readonly updateBusinessTripTravelAndSubsistenceExpense: Scalars['UUID']['output'];
  readonly updateCharge: UpdateChargeResult;
  readonly updateChargeAccountantApproval: AccountantStatus;
  readonly updateChargeBusinessTrip?: Maybe<Charge>;
  readonly updateDepreciationCategory: UpdateDepreciationCategoryResult;
  readonly updateDepreciationRecord: UpdateDepreciationRecordResult;
  readonly updateDocument: UpdateDocumentResult;
  readonly updateDynamicReportTemplate: DynamicReportInfo;
  readonly updateDynamicReportTemplateName: DynamicReportInfo;
  readonly updateMiscExpense: MiscExpense;
  readonly updateSalaryRecord: UpdateSalaryRecordResult;
  readonly updateTag: Scalars['Boolean']['output'];
  readonly updateTagParent: Scalars['Boolean']['output'];
  readonly updateTagPart: Scalars['Boolean']['output'];
  readonly updateTaxCategory: UpdateTaxCategoryResponse;
  readonly updateTransaction: UpdateTransactionResult;
  readonly uploadDocument: UploadDocumentResult;
};


/**  mutation root  */
export type MutationAddBusinessTripAccommodationsExpenseArgs = {
  fields: AddBusinessTripAccommodationsExpenseInput;
};


/**  mutation root  */
export type MutationAddBusinessTripCarRentalExpenseArgs = {
  fields: AddBusinessTripCarRentalExpenseInput;
};


/**  mutation root  */
export type MutationAddBusinessTripFlightsExpenseArgs = {
  fields: AddBusinessTripFlightsExpenseInput;
};


/**  mutation root  */
export type MutationAddBusinessTripOtherExpenseArgs = {
  fields: AddBusinessTripOtherExpenseInput;
};


/**  mutation root  */
export type MutationAddBusinessTripTravelAndSubsistenceExpenseArgs = {
  fields: AddBusinessTripTravelAndSubsistenceExpenseInput;
};


/**  mutation root  */
export type MutationAddTagArgs = {
  name: Scalars['String']['input'];
  parentId?: InputMaybe<Scalars['UUID']['input']>;
};


/**  mutation root  */
export type MutationBatchUploadDocumentsArgs = {
  chargeId?: InputMaybe<Scalars['UUID']['input']>;
  documents: ReadonlyArray<Scalars['FileScalar']['input']>;
  isSensitive?: InputMaybe<Scalars['Boolean']['input']>;
};


/**  mutation root  */
export type MutationBatchUploadDocumentsFromGoogleDriveArgs = {
  chargeId?: InputMaybe<Scalars['UUID']['input']>;
  isSensitive?: InputMaybe<Scalars['Boolean']['input']>;
  sharedFolderUrl: Scalars['String']['input'];
};


/**  mutation root  */
export type MutationCategorizeBusinessTripExpenseArgs = {
  fields: CategorizeBusinessTripExpenseInput;
};


/**  mutation root  */
export type MutationCategorizeIntoExistingBusinessTripExpenseArgs = {
  fields: CategorizeIntoExistingBusinessTripExpenseInput;
};


/**  mutation root  */
export type MutationCreditShareholdersBusinessTripTravelAndSubsistenceArgs = {
  businessTripId: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationDeleteBusinessTripAttendeeArgs = {
  fields: DeleteBusinessTripAttendeeInput;
};


/**  mutation root  */
export type MutationDeleteBusinessTripExpenseArgs = {
  businessTripExpenseId: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationDeleteChargeArgs = {
  chargeId: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationDeleteDepreciationCategoryArgs = {
  depreciationCategoryId: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationDeleteDepreciationRecordArgs = {
  depreciationRecordId: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationDeleteDocumentArgs = {
  documentId: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationDeleteDynamicReportTemplateArgs = {
  name: Scalars['String']['input'];
};


/**  mutation root  */
export type MutationDeleteMiscExpenseArgs = {
  id: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationDeleteTagArgs = {
  id: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationFetchIncomeDocumentsArgs = {
  ownerId: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationGenerateBankDepositsRevaluationChargeArgs = {
  date: Scalars['TimelessDate']['input'];
  ownerId: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationGenerateDepreciationChargeArgs = {
  ownerId: Scalars['UUID']['input'];
  year: Scalars['TimelessDate']['input'];
};


/**  mutation root  */
export type MutationGenerateRecoveryReserveChargeArgs = {
  ownerId: Scalars['UUID']['input'];
  year: Scalars['TimelessDate']['input'];
};


/**  mutation root  */
export type MutationGenerateRevaluationChargeArgs = {
  date: Scalars['TimelessDate']['input'];
  ownerId: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationGenerateTaxExpensesChargeArgs = {
  ownerId: Scalars['UUID']['input'];
  year: Scalars['TimelessDate']['input'];
};


/**  mutation root  */
export type MutationGenerateVacationReserveChargeArgs = {
  ownerId: Scalars['UUID']['input'];
  year: Scalars['TimelessDate']['input'];
};


/**  mutation root  */
export type MutationInsertBusinessTripArgs = {
  fields: InsertBusinessTripInput;
};


/**  mutation root  */
export type MutationInsertBusinessTripAttendeeArgs = {
  fields: InsertBusinessTripAttendeeInput;
};


/**  mutation root  */
export type MutationInsertDepreciationCategoryArgs = {
  input: InsertDepreciationCategoryInput;
};


/**  mutation root  */
export type MutationInsertDepreciationRecordArgs = {
  input: InsertDepreciationRecordInput;
};


/**  mutation root  */
export type MutationInsertDocumentArgs = {
  record: InsertDocumentInput;
};


/**  mutation root  */
export type MutationInsertDynamicReportTemplateArgs = {
  name: Scalars['String']['input'];
  template: Scalars['String']['input'];
};


/**  mutation root  */
export type MutationInsertMiscExpenseArgs = {
  fields: InsertMiscExpenseInput;
};


/**  mutation root  */
export type MutationInsertNewBusinessArgs = {
  fields: InsertNewBusinessInput;
};


/**  mutation root  */
export type MutationInsertOrUpdateSalaryRecordsArgs = {
  salaryRecords: ReadonlyArray<SalaryRecordInput>;
};


/**  mutation root  */
export type MutationInsertSalaryRecordsArgs = {
  salaryRecords: ReadonlyArray<SalaryRecordInput>;
};


/**  mutation root  */
export type MutationInsertSalaryRecordsFromFileArgs = {
  chargeId: Scalars['UUID']['input'];
  file: Scalars['FileScalar']['input'];
};


/**  mutation root  */
export type MutationInsertTaxCategoryArgs = {
  fields: InsertTaxCategoryInput;
};


/**  mutation root  */
export type MutationMergeBusinessesArgs = {
  businessIdsToMerge: ReadonlyArray<Scalars['UUID']['input']>;
  targetBusinessId: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationMergeChargesArgs = {
  baseChargeID: Scalars['UUID']['input'];
  chargeIdsToMerge: ReadonlyArray<Scalars['UUID']['input']>;
  fields?: InputMaybe<UpdateChargeInput>;
};


/**  mutation root  */
export type MutationRegenerateLedgerRecordsArgs = {
  chargeId: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationUncategorizePartialBusinessTripExpenseArgs = {
  businessTripExpenseId: Scalars['UUID']['input'];
  transactionId: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationUpdateBusinessArgs = {
  businessId: Scalars['UUID']['input'];
  fields: UpdateBusinessInput;
  ownerId: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationUpdateBusinessTripArgs = {
  fields: UpdateBusinessTripInput;
};


/**  mutation root  */
export type MutationUpdateBusinessTripAccommodationsExpenseArgs = {
  fields: UpdateBusinessTripAccommodationsExpenseInput;
};


/**  mutation root  */
export type MutationUpdateBusinessTripAccountantApprovalArgs = {
  approvalStatus: AccountantStatus;
  businessTripId: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationUpdateBusinessTripAttendeeArgs = {
  fields: BusinessTripAttendeeUpdateInput;
};


/**  mutation root  */
export type MutationUpdateBusinessTripCarRentalExpenseArgs = {
  fields: UpdateBusinessTripCarRentalExpenseInput;
};


/**  mutation root  */
export type MutationUpdateBusinessTripFlightsExpenseArgs = {
  fields: UpdateBusinessTripFlightsExpenseInput;
};


/**  mutation root  */
export type MutationUpdateBusinessTripOtherExpenseArgs = {
  fields: UpdateBusinessTripOtherExpenseInput;
};


/**  mutation root  */
export type MutationUpdateBusinessTripTravelAndSubsistenceExpenseArgs = {
  fields: UpdateBusinessTripTravelAndSubsistenceExpenseInput;
};


/**  mutation root  */
export type MutationUpdateChargeArgs = {
  chargeId: Scalars['UUID']['input'];
  fields: UpdateChargeInput;
};


/**  mutation root  */
export type MutationUpdateChargeAccountantApprovalArgs = {
  approvalStatus: AccountantStatus;
  chargeId: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationUpdateChargeBusinessTripArgs = {
  businessTripId?: InputMaybe<Scalars['UUID']['input']>;
  chargeId: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationUpdateDepreciationCategoryArgs = {
  input: UpdateDepreciationCategoryInput;
};


/**  mutation root  */
export type MutationUpdateDepreciationRecordArgs = {
  input: UpdateDepreciationRecordInput;
};


/**  mutation root  */
export type MutationUpdateDocumentArgs = {
  documentId: Scalars['UUID']['input'];
  fields: UpdateDocumentFieldsInput;
};


/**  mutation root  */
export type MutationUpdateDynamicReportTemplateArgs = {
  name: Scalars['String']['input'];
  template: Scalars['String']['input'];
};


/**  mutation root  */
export type MutationUpdateDynamicReportTemplateNameArgs = {
  name: Scalars['String']['input'];
  newName: Scalars['String']['input'];
};


/**  mutation root  */
export type MutationUpdateMiscExpenseArgs = {
  fields: UpdateMiscExpenseInput;
  id: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationUpdateSalaryRecordArgs = {
  salaryRecord: SalaryRecordEditInput;
};


/**  mutation root  */
export type MutationUpdateTagArgs = {
  fields: UpdateTagFieldsInput;
  id: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationUpdateTagParentArgs = {
  id: Scalars['UUID']['input'];
  parentId?: InputMaybe<Scalars['UUID']['input']>;
};


/**  mutation root  */
export type MutationUpdateTagPartArgs = {
  chargeId: Scalars['UUID']['input'];
  part: Scalars['Float']['input'];
  tagId: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationUpdateTaxCategoryArgs = {
  fields: UpdateTaxCategoryInput;
  taxCategoryId: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationUpdateTransactionArgs = {
  fields: UpdateTransactionInput;
  transactionId: Scalars['UUID']['input'];
};


/**  mutation root  */
export type MutationUploadDocumentArgs = {
  chargeId?: InputMaybe<Scalars['UUID']['input']>;
  file: Scalars['FileScalar']['input'];
};

/**  processed non-financial document  */
export type OtherDocument = Document & Linkable & {
  readonly __typename?: 'OtherDocument';
  readonly charge?: Maybe<Charge>;
  readonly documentType?: Maybe<DocumentType>;
  readonly file?: Maybe<Scalars['URL']['output']>;
  readonly id: Scalars['UUID']['output'];
  readonly image?: Maybe<Scalars['URL']['output']>;
  readonly isReviewed?: Maybe<Scalars['Boolean']['output']>;
};

/**  result type for pcnFile  */
export type PcnFileResult = {
  readonly __typename?: 'PCNFileResult';
  readonly fileName: Scalars['String']['output'];
  readonly reportContent: Scalars['String']['output'];
};

/**  config options for generatePCN  */
export type PcnOptionsInput = {
  readonly strict?: InputMaybe<Scalars['Boolean']['input']>;
};

/**  meta info for page pagination  */
export type PageInfo = {
  readonly __typename?: 'PageInfo';
  readonly currentPage?: Maybe<Scalars['Int']['output']>;
  readonly pageSize?: Maybe<Scalars['Int']['output']>;
  readonly totalPages: Scalars['Int']['output'];
};

/**  response for paginated Financial Entities  */
export type PaginatedBusinesses = {
  readonly __typename?: 'PaginatedBusinesses';
  readonly nodes: ReadonlyArray<Business>;
  readonly pageInfo: PageInfo;
};

/**  response for paginated charges  */
export type PaginatedCharges = {
  readonly __typename?: 'PaginatedCharges';
  readonly nodes: ReadonlyArray<Charge>;
  readonly pageInfo: PageInfo;
};

/**  response for paginated Financial Entities  */
export type PaginatedFinancialEntities = {
  readonly __typename?: 'PaginatedFinancialEntities';
  readonly nodes: ReadonlyArray<FinancialEntity>;
  readonly pageInfo: PageInfo;
};

/**  represent pension fund */
export type PensionFund = Fund & {
  readonly __typename?: 'PensionFund';
  readonly id: Scalars['UUID']['output'];
  readonly name: Scalars['String']['output'];
};

/**  Financial entity, identifier by ID, represents an actual person  */
export type PersonalFinancialEntity = Business & FinancialEntity & {
  readonly __typename?: 'PersonalFinancialEntity';
  readonly accounts: ReadonlyArray<FinancialAccount>;
  readonly charges: PaginatedCharges;
  readonly email: Scalars['String']['output'];
  readonly id: Scalars['UUID']['output'];
  readonly name: Scalars['String']['output'];
  readonly sortCode?: Maybe<SortCode>;
};


/**  Financial entity, identifier by ID, represents an actual person  */
export type PersonalFinancialEntityChargesArgs = {
  filter?: InputMaybe<ChargeFilter>;
  limit?: InputMaybe<Scalars['Int']['input']>;
  page?: InputMaybe<Scalars['Int']['input']>;
};

/**  result type for profitAndLossReport  */
export type ProfitAndLossReport = {
  readonly __typename?: 'ProfitAndLossReport';
  readonly id: Scalars['ID']['output'];
  readonly reference: ReadonlyArray<ProfitAndLossReportYear>;
  readonly report: ProfitAndLossReportYear;
};

/**  profit and loss data for a single year  */
export type ProfitAndLossReportYear = {
  readonly __typename?: 'ProfitAndLossReportYear';
  readonly costOfSales: ReportCommentary;
  readonly financialExpenses: ReportCommentary;
  readonly grossProfit: FinancialAmount;
  readonly id: Scalars['ID']['output'];
  readonly managementAndGeneralExpenses: ReportCommentary;
  readonly marketingExpenses: ReportCommentary;
  readonly netProfit: FinancialAmount;
  readonly operatingProfit: FinancialAmount;
  readonly otherIncome: ReportCommentary;
  readonly profitBeforeTax: FinancialAmount;
  readonly researchAndDevelopmentExpenses: ReportCommentary;
  readonly revenue: ReportCommentary;
  readonly tax: FinancialAmount;
  readonly year: Scalars['Int']['output'];
};

/**  proforma document  */
export type Proforma = Document & FinancialDocument & Linkable & {
  readonly __typename?: 'Proforma';
  readonly amount?: Maybe<FinancialAmount>;
  readonly charge?: Maybe<Charge>;
  readonly creditor?: Maybe<FinancialEntity>;
  readonly date?: Maybe<Scalars['TimelessDate']['output']>;
  readonly debtor?: Maybe<FinancialEntity>;
  readonly documentType?: Maybe<DocumentType>;
  readonly file?: Maybe<Scalars['URL']['output']>;
  readonly id: Scalars['UUID']['output'];
  readonly image?: Maybe<Scalars['URL']['output']>;
  readonly isReviewed?: Maybe<Scalars['Boolean']['output']>;
  readonly missingInfoSuggestions?: Maybe<DocumentSuggestions>;
  readonly noVatAmount?: Maybe<Scalars['Float']['output']>;
  readonly serialNumber?: Maybe<Scalars['String']['output']>;
  readonly vat?: Maybe<FinancialAmount>;
  readonly vatReportDateOverride?: Maybe<Scalars['TimelessDate']['output']>;
};

/** query root  */
export type Query = {
  readonly __typename?: 'Query';
  readonly allBusinessTrips: ReadonlyArray<BusinessTrip>;
  readonly allBusinesses?: Maybe<PaginatedBusinesses>;
  readonly allCharges: PaginatedCharges;
  readonly allCountries: ReadonlyArray<Country>;
  readonly allDynamicReports: ReadonlyArray<DynamicReportInfo>;
  readonly allFinancialAccounts: ReadonlyArray<FinancialAccount>;
  /**  TODO: This is temporary, should be replaced after auth and financial entities hierarchy is implemented  */
  readonly allFinancialEntities?: Maybe<PaginatedFinancialEntities>;
  readonly allPensionFunds: ReadonlyArray<PensionFund>;
  readonly allSortCodes: ReadonlyArray<SortCode>;
  readonly allTags: ReadonlyArray<Tag>;
  readonly allTrainingFunds: ReadonlyArray<TrainingFund>;
  readonly business: Business;
  readonly businessTransactionsFromLedgerRecords: BusinessTransactionsFromLedgerRecordsResult;
  readonly businessTransactionsSumFromLedgerRecords: BusinessTransactionsSumFromLedgerRecordsResult;
  readonly businessTrip?: Maybe<BusinessTrip>;
  readonly businesses: ReadonlyArray<Business>;
  readonly chargesByIDs: ReadonlyArray<Charge>;
  readonly chargesWithLedgerChanges: ReadonlyArray<ChargesWithLedgerChangesResult>;
  readonly chargesWithMissingRequiredInfo: PaginatedCharges;
  readonly corporateTaxByDate: CorporateTax;
  readonly corporateTaxRulingComplianceReport: ReadonlyArray<CorporateTaxRulingComplianceReport>;
  readonly depreciationCategories: ReadonlyArray<DepreciationCategory>;
  readonly depreciationRecordsByCharge: ReadonlyArray<DepreciationRecord>;
  readonly documentById?: Maybe<Document>;
  readonly documents: ReadonlyArray<Document>;
  readonly documentsByFilters: ReadonlyArray<Document>;
  readonly dynamicReport: DynamicReportInfo;
  readonly employeesByEmployerId: ReadonlyArray<Employee>;
  /**  get exchage rates by date  */
  readonly exchangeRates?: Maybe<ExchangeRates>;
  readonly financialEntity: FinancialEntity;
  readonly incomeExpenseChart: IncomeExpenseChart;
  readonly ledgerRecordsByDates: ReadonlyArray<LedgerRecord>;
  readonly miscExpensesByCharge: ReadonlyArray<MiscExpense>;
  readonly pcnFile: PcnFileResult;
  readonly ping?: Maybe<Scalars['Boolean']['output']>;
  readonly profitAndLossReport: ProfitAndLossReport;
  readonly salaryRecordsByCharge: ReadonlyArray<Salary>;
  readonly salaryRecordsByDates: ReadonlyArray<Salary>;
  /**  get similar transactions  */
  readonly similarTransactions: ReadonlyArray<Transaction>;
  readonly taxCategories: ReadonlyArray<TaxCategory>;
  readonly taxCategory: TaxCategory;
  readonly taxCategoryByBusinessId?: Maybe<TaxCategory>;
  readonly taxReport: TaxReport;
  readonly transactionsByIDs: ReadonlyArray<Transaction>;
  readonly vatReport: VatReportResult;
  readonly yearlyLedgerReport: YearlyLedgerReport;
};


/** query root  */
export type QueryAllBusinessesArgs = {
  limit?: InputMaybe<Scalars['Int']['input']>;
  name?: InputMaybe<Scalars['String']['input']>;
  page?: InputMaybe<Scalars['Int']['input']>;
};


/** query root  */
export type QueryAllChargesArgs = {
  filters?: InputMaybe<ChargeFilter>;
  limit?: InputMaybe<Scalars['Int']['input']>;
  page?: InputMaybe<Scalars['Int']['input']>;
};


/** query root  */
export type QueryAllFinancialEntitiesArgs = {
  limit?: InputMaybe<Scalars['Int']['input']>;
  page?: InputMaybe<Scalars['Int']['input']>;
};


/** query root  */
export type QueryBusinessArgs = {
  id: Scalars['UUID']['input'];
};


/** query root  */
export type QueryBusinessTransactionsFromLedgerRecordsArgs = {
  filters?: InputMaybe<BusinessTransactionsFilter>;
};


/** query root  */
export type QueryBusinessTransactionsSumFromLedgerRecordsArgs = {
  filters?: InputMaybe<BusinessTransactionsFilter>;
};


/** query root  */
export type QueryBusinessTripArgs = {
  id: Scalars['UUID']['input'];
};


/** query root  */
export type QueryBusinessesArgs = {
  ids: ReadonlyArray<Scalars['UUID']['input']>;
};


/** query root  */
export type QueryChargesByIDsArgs = {
  chargeIDs: ReadonlyArray<Scalars['UUID']['input']>;
};


/** query root  */
export type QueryChargesWithLedgerChangesArgs = {
  filters?: InputMaybe<ChargeFilter>;
  limit?: InputMaybe<Scalars['Int']['input']>;
};


/** query root  */
export type QueryChargesWithMissingRequiredInfoArgs = {
  limit?: InputMaybe<Scalars['Int']['input']>;
  page?: InputMaybe<Scalars['Int']['input']>;
};


/** query root  */
export type QueryCorporateTaxByDateArgs = {
  date: Scalars['TimelessDate']['input'];
};


/** query root  */
export type QueryCorporateTaxRulingComplianceReportArgs = {
  years: ReadonlyArray<Scalars['Int']['input']>;
};


/** query root  */
export type QueryDepreciationRecordsByChargeArgs = {
  chargeId: Scalars['UUID']['input'];
};


/** query root  */
export type QueryDocumentByIdArgs = {
  documentId: Scalars['UUID']['input'];
};


/** query root  */
export type QueryDocumentsByFiltersArgs = {
  filters: DocumentsFilters;
};


/** query root  */
export type QueryDynamicReportArgs = {
  name: Scalars['String']['input'];
};


/** query root  */
export type QueryEmployeesByEmployerIdArgs = {
  employerId: Scalars['UUID']['input'];
};


/** query root  */
export type QueryExchangeRatesArgs = {
  date?: InputMaybe<Scalars['TimelessDate']['input']>;
};


/** query root  */
export type QueryFinancialEntityArgs = {
  id: Scalars['UUID']['input'];
};


/** query root  */
export type QueryIncomeExpenseChartArgs = {
  filters: IncomeExpenseChartFilters;
};


/** query root  */
export type QueryLedgerRecordsByDatesArgs = {
  fromDate: Scalars['TimelessDate']['input'];
  toDate: Scalars['TimelessDate']['input'];
};


/** query root  */
export type QueryMiscExpensesByChargeArgs = {
  chargeId: Scalars['UUID']['input'];
};


/** query root  */
export type QueryPcnFileArgs = {
  financialEntityId: Scalars['UUID']['input'];
  fromDate: Scalars['TimelessDate']['input'];
  options?: InputMaybe<PcnOptionsInput>;
  toDate: Scalars['TimelessDate']['input'];
};


/** query root  */
export type QueryProfitAndLossReportArgs = {
  referenceYears: ReadonlyArray<Scalars['Int']['input']>;
  reportYear: Scalars['Int']['input'];
};


/** query root  */
export type QuerySalaryRecordsByChargeArgs = {
  chargeId: Scalars['UUID']['input'];
};


/** query root  */
export type QuerySalaryRecordsByDatesArgs = {
  employeeIDs?: InputMaybe<ReadonlyArray<Scalars['UUID']['input']>>;
  fromDate: Scalars['TimelessDate']['input'];
  toDate: Scalars['TimelessDate']['input'];
};


/** query root  */
export type QuerySimilarTransactionsArgs = {
  transactionId: Scalars['UUID']['input'];
  withMissingInfo?: InputMaybe<Scalars['Boolean']['input']>;
};


/** query root  */
export type QueryTaxCategoryArgs = {
  id: Scalars['UUID']['input'];
};


/** query root  */
export type QueryTaxCategoryByBusinessIdArgs = {
  businessId: Scalars['UUID']['input'];
  ownerId: Scalars['UUID']['input'];
};


/** query root  */
export type QueryTaxReportArgs = {
  referenceYears: ReadonlyArray<Scalars['Int']['input']>;
  reportYear: Scalars['Int']['input'];
};


/** query root  */
export type QueryTransactionsByIDsArgs = {
  transactionIDs: ReadonlyArray<Scalars['UUID']['input']>;
};


/** query root  */
export type QueryVatReportArgs = {
  filters?: InputMaybe<VatReportFilter>;
};


/** query root  */
export type QueryYearlyLedgerReportArgs = {
  year: Scalars['Int']['input'];
};

/**  receipt document  */
export type Receipt = Document & FinancialDocument & Linkable & {
  readonly __typename?: 'Receipt';
  readonly amount?: Maybe<FinancialAmount>;
  readonly charge?: Maybe<Charge>;
  readonly creditor?: Maybe<FinancialEntity>;
  readonly date?: Maybe<Scalars['TimelessDate']['output']>;
  readonly debtor?: Maybe<FinancialEntity>;
  readonly documentType?: Maybe<DocumentType>;
  readonly file?: Maybe<Scalars['URL']['output']>;
  readonly id: Scalars['UUID']['output'];
  readonly image?: Maybe<Scalars['URL']['output']>;
  readonly isReviewed?: Maybe<Scalars['Boolean']['output']>;
  readonly missingInfoSuggestions?: Maybe<DocumentSuggestions>;
  readonly noVatAmount?: Maybe<Scalars['Float']['output']>;
  readonly serialNumber?: Maybe<Scalars['String']['output']>;
  readonly vat?: Maybe<FinancialAmount>;
  readonly vatReportDateOverride?: Maybe<Scalars['TimelessDate']['output']>;
};

/**  Tax report commentary summary  */
export type ReportCommentary = {
  readonly __typename?: 'ReportCommentary';
  readonly amount: FinancialAmount;
  readonly records: ReadonlyArray<ReportCommentaryRecord>;
};

/**  Report commentary record  */
export type ReportCommentaryRecord = {
  readonly __typename?: 'ReportCommentaryRecord';
  readonly amount: FinancialAmount;
  readonly records: ReadonlyArray<ReportCommentarySubRecord>;
  readonly sortCode: SortCode;
};

/**  Report commentary sub-record  */
export type ReportCommentarySubRecord = {
  readonly __typename?: 'ReportCommentarySubRecord';
  readonly amount: FinancialAmount;
  readonly financialEntity: FinancialEntity;
};

/**  Role based authorization */
export type Role =
  | 'ACCOUNTANT'
  | 'ADMIN';

/**  defines salary records for charge arrangement */
export type Salary = {
  readonly __typename?: 'Salary';
  readonly baseAmount?: Maybe<FinancialAmount>;
  readonly bonus?: Maybe<FinancialAmount>;
  readonly charge?: Maybe<SalaryCharge>;
  readonly compensationsAmount?: Maybe<FinancialAmount>;
  readonly compensationsPercentage?: Maybe<Scalars['Float']['output']>;
  readonly directAmount: FinancialAmount;
  readonly employee?: Maybe<LtdFinancialEntity>;
  readonly employer?: Maybe<LtdFinancialEntity>;
  readonly gift?: Maybe<FinancialAmount>;
  readonly globalAdditionalHoursAmount?: Maybe<FinancialAmount>;
  readonly healthInsuranceAmount?: Maybe<FinancialAmount>;
  readonly incomeTaxAmount?: Maybe<FinancialAmount>;
  readonly month: Scalars['String']['output'];
  readonly notionalExpense?: Maybe<FinancialAmount>;
  readonly pensionEmployeeAmount?: Maybe<FinancialAmount>;
  readonly pensionEmployeePercentage?: Maybe<Scalars['Float']['output']>;
  readonly pensionEmployerAmount?: Maybe<FinancialAmount>;
  readonly pensionEmployerPercentage?: Maybe<Scalars['Float']['output']>;
  readonly pensionFund?: Maybe<LtdFinancialEntity>;
  readonly recovery?: Maybe<FinancialAmount>;
  readonly sicknessDays?: Maybe<SicknessDays>;
  readonly socialSecurityEmployeeAmount?: Maybe<FinancialAmount>;
  readonly socialSecurityEmployerAmount?: Maybe<FinancialAmount>;
  readonly trainingFund?: Maybe<LtdFinancialEntity>;
  readonly trainingFundEmployeeAmount?: Maybe<FinancialAmount>;
  readonly trainingFundEmployeePercentage?: Maybe<Scalars['Float']['output']>;
  readonly trainingFundEmployerAmount?: Maybe<FinancialAmount>;
  readonly trainingFundEmployerPercentage?: Maybe<Scalars['Float']['output']>;
  readonly vacationDays?: Maybe<VacationDays>;
  readonly vacationTakeout?: Maybe<FinancialAmount>;
  readonly workDays?: Maybe<Scalars['Float']['output']>;
};

/**  charge with conversion transactions  */
export type SalaryCharge = Charge & {
  readonly __typename?: 'SalaryCharge';
  readonly accountantApproval: AccountantStatus;
  readonly additionalDocuments: ReadonlyArray<Document>;
  readonly conversion?: Maybe<Scalars['Boolean']['output']>;
  readonly counterparty?: Maybe<FinancialEntity>;
  readonly employees: ReadonlyArray<LtdFinancialEntity>;
  readonly exchangeRates?: Maybe<ExchangeRates>;
  readonly id: Scalars['UUID']['output'];
  readonly isInvoicePaymentDifferentCurrency?: Maybe<Scalars['Boolean']['output']>;
  readonly ledger: Ledger;
  readonly metadata?: Maybe<ChargeMetadata>;
  readonly minDebitDate?: Maybe<Scalars['DateTime']['output']>;
  readonly minDocumentsDate?: Maybe<Scalars['DateTime']['output']>;
  readonly minEventDate?: Maybe<Scalars['DateTime']['output']>;
  readonly miscExpenses: ReadonlyArray<MiscExpense>;
  readonly missingInfoSuggestions?: Maybe<ChargeSuggestions>;
  readonly optionalVAT?: Maybe<Scalars['Boolean']['output']>;
  readonly owner: Business;
  readonly property?: Maybe<Scalars['Boolean']['output']>;
  readonly salary?: Maybe<Scalars['Boolean']['output']>;
  readonly salaryRecords: ReadonlyArray<Salary>;
  readonly tags: ReadonlyArray<Tag>;
  readonly taxCategory?: Maybe<TaxCategory>;
  readonly totalAmount?: Maybe<FinancialAmount>;
  readonly transactions: ReadonlyArray<Transaction>;
  readonly userDescription?: Maybe<Scalars['String']['output']>;
  readonly validationData?: Maybe<ValidationData>;
  readonly vat?: Maybe<FinancialAmount>;
  readonly withholdingTax?: Maybe<FinancialAmount>;
  readonly yearsOfRelevance?: Maybe<ReadonlyArray<YearOfRelevance>>;
};

/**  input variables for update salary records  */
export type SalaryRecordEditInput = {
  readonly addedVacationDays?: InputMaybe<Scalars['Float']['input']>;
  readonly baseSalary?: InputMaybe<Scalars['Float']['input']>;
  readonly bonus?: InputMaybe<Scalars['Float']['input']>;
  readonly chargeId?: InputMaybe<Scalars['UUID']['input']>;
  readonly compensationsEmployerAmount?: InputMaybe<Scalars['Float']['input']>;
  readonly compensationsEmployerPercentage?: InputMaybe<Scalars['Float']['input']>;
  readonly directPaymentAmount?: InputMaybe<Scalars['Float']['input']>;
  readonly employeeId: Scalars['UUID']['input'];
  readonly employer?: InputMaybe<Scalars['UUID']['input']>;
  readonly gift?: InputMaybe<Scalars['Float']['input']>;
  readonly globalAdditionalHours?: InputMaybe<Scalars['Float']['input']>;
  readonly healthPaymentAmount?: InputMaybe<Scalars['Float']['input']>;
  readonly hourlyRate?: InputMaybe<Scalars['Float']['input']>;
  readonly hours?: InputMaybe<Scalars['Float']['input']>;
  readonly month: Scalars['String']['input'];
  readonly pensionEmployeeAmount?: InputMaybe<Scalars['Float']['input']>;
  readonly pensionEmployeePercentage?: InputMaybe<Scalars['Float']['input']>;
  readonly pensionEmployerAmount?: InputMaybe<Scalars['Float']['input']>;
  readonly pensionEmployerPercentage?: InputMaybe<Scalars['Float']['input']>;
  readonly pensionFundId?: InputMaybe<Scalars['UUID']['input']>;
  readonly recovery?: InputMaybe<Scalars['Float']['input']>;
  readonly sicknessDaysBalance?: InputMaybe<Scalars['Float']['input']>;
  readonly socialSecurityAmountEmployee?: InputMaybe<Scalars['Float']['input']>;
  readonly socialSecurityAmountEmployer?: InputMaybe<Scalars['Float']['input']>;
  readonly taxAmount?: InputMaybe<Scalars['Float']['input']>;
  readonly trainingFundEmployeeAmount?: InputMaybe<Scalars['Float']['input']>;
  readonly trainingFundEmployeePercentage?: InputMaybe<Scalars['Float']['input']>;
  readonly trainingFundEmployerAmount?: InputMaybe<Scalars['Float']['input']>;
  readonly trainingFundEmployerPercentage?: InputMaybe<Scalars['Float']['input']>;
  readonly trainingFundId?: InputMaybe<Scalars['UUID']['input']>;
  readonly vacationDaysBalance?: InputMaybe<Scalars['Float']['input']>;
  readonly vacationTakeout?: InputMaybe<Scalars['Float']['input']>;
  readonly workDays?: InputMaybe<Scalars['Float']['input']>;
  readonly zkufot?: InputMaybe<Scalars['Int']['input']>;
};

/**  input variables for insert salary records  */
export type SalaryRecordInput = {
  readonly addedVacationDays?: InputMaybe<Scalars['Float']['input']>;
  readonly baseSalary?: InputMaybe<Scalars['Float']['input']>;
  readonly bonus?: InputMaybe<Scalars['Float']['input']>;
  readonly chargeId?: InputMaybe<Scalars['UUID']['input']>;
  readonly compensationsEmployerAmount?: InputMaybe<Scalars['Float']['input']>;
  readonly compensationsEmployerPercentage?: InputMaybe<Scalars['Float']['input']>;
  readonly directPaymentAmount: Scalars['Float']['input'];
  readonly employee?: InputMaybe<Scalars['String']['input']>;
  readonly employeeId: Scalars['UUID']['input'];
  readonly employer: Scalars['UUID']['input'];
  readonly gift?: InputMaybe<Scalars['Float']['input']>;
  readonly globalAdditionalHours?: InputMaybe<Scalars['Float']['input']>;
  readonly healthPaymentAmount?: InputMaybe<Scalars['Float']['input']>;
  readonly hourlyRate?: InputMaybe<Scalars['Float']['input']>;
  readonly hours?: InputMaybe<Scalars['Float']['input']>;
  readonly jobPercentage?: InputMaybe<Scalars['Float']['input']>;
  readonly month: Scalars['String']['input'];
  readonly pensionEmployeeAmount?: InputMaybe<Scalars['Float']['input']>;
  readonly pensionEmployeePercentage?: InputMaybe<Scalars['Float']['input']>;
  readonly pensionEmployerAmount?: InputMaybe<Scalars['Float']['input']>;
  readonly pensionEmployerPercentage?: InputMaybe<Scalars['Float']['input']>;
  readonly pensionFundId?: InputMaybe<Scalars['UUID']['input']>;
  readonly recovery?: InputMaybe<Scalars['Float']['input']>;
  readonly sicknessDaysBalance?: InputMaybe<Scalars['Float']['input']>;
  readonly socialSecurityAmountEmployee?: InputMaybe<Scalars['Float']['input']>;
  readonly socialSecurityAmountEmployer?: InputMaybe<Scalars['Float']['input']>;
  readonly taxAmount?: InputMaybe<Scalars['Float']['input']>;
  readonly trainingFundEmployeeAmount?: InputMaybe<Scalars['Float']['input']>;
  readonly trainingFundEmployeePercentage?: InputMaybe<Scalars['Float']['input']>;
  readonly trainingFundEmployerAmount?: InputMaybe<Scalars['Float']['input']>;
  readonly trainingFundEmployerPercentage?: InputMaybe<Scalars['Float']['input']>;
  readonly trainingFundId?: InputMaybe<Scalars['UUID']['input']>;
  readonly vacationDaysBalance?: InputMaybe<Scalars['Float']['input']>;
  readonly vacationTakeout?: InputMaybe<Scalars['Float']['input']>;
  readonly workDays?: InputMaybe<Scalars['Float']['input']>;
  readonly zkufot?: InputMaybe<Scalars['Int']['input']>;
};

/**  defines sickness days for salary record  */
export type SicknessDays = {
  readonly __typename?: 'SicknessDays';
  readonly balance?: Maybe<Scalars['Float']['output']>;
};

/**  Ledger record with balance  */
export type SingleSidedLedgerRecord = {
  readonly __typename?: 'SingleSidedLedgerRecord';
  readonly amount: FinancialAmount;
  readonly balance: Scalars['Float']['output'];
  readonly counterParty?: Maybe<FinancialEntity>;
  readonly description?: Maybe<Scalars['String']['output']>;
  readonly id: Scalars['ID']['output'];
  readonly invoiceDate: Scalars['DateTime']['output'];
  readonly reference?: Maybe<Scalars['String']['output']>;
  readonly valueDate: Scalars['DateTime']['output'];
};

/**  Sort Code  */
export type SortCode = {
  readonly __typename?: 'SortCode';
  readonly id: Scalars['Int']['output'];
  readonly name?: Maybe<Scalars['String']['output']>;
};

/**  input for business suggestions  */
export type Suggestions = {
  readonly __typename?: 'Suggestions';
  readonly description?: Maybe<Scalars['String']['output']>;
  readonly phrases: ReadonlyArray<Scalars['String']['output']>;
  readonly tags: ReadonlyArray<Tag>;
};

/**  input for business suggestions  */
export type SuggestionsInput = {
  readonly description?: InputMaybe<Scalars['String']['input']>;
  readonly phrases?: InputMaybe<ReadonlyArray<Scalars['String']['input']>>;
  readonly tags?: InputMaybe<ReadonlyArray<TagInput>>;
};

/**  defines a tag / category for charge arrangement */
export type Tag = {
  readonly __typename?: 'Tag';
  readonly fullPath?: Maybe<ReadonlyArray<Tag>>;
  readonly id: Scalars['UUID']['output'];
  readonly name: Scalars['String']['output'];
  readonly namePath?: Maybe<ReadonlyArray<Scalars['String']['output']>>;
  readonly parent?: Maybe<Tag>;
};

/**  input variables for Tag */
export type TagInput = {
  readonly id: Scalars['String']['input'];
};

/**  Tax category entity used for ledger records  */
export type TaxCategory = FinancialEntity & {
  readonly __typename?: 'TaxCategory';
  readonly id: Scalars['UUID']['output'];
  readonly name: Scalars['String']['output'];
  readonly sortCode?: Maybe<SortCode>;
};

/**  result type for taxReport  */
export type TaxReport = {
  readonly __typename?: 'TaxReport';
  readonly id: Scalars['ID']['output'];
  readonly reference: ReadonlyArray<TaxReportYear>;
  readonly report: TaxReportYear;
};

/**  tax data for a single year  */
export type TaxReportYear = {
  readonly __typename?: 'TaxReportYear';
  readonly annualTaxExpense: FinancialAmount;
  readonly businessTripsExcessExpensesAmount: FinancialAmount;
  readonly fines: ReportCommentary;
  readonly id: Scalars['ID']['output'];
  readonly profitBeforeTax: ReportCommentary;
  readonly researchAndDevelopmentExpensesByRecords: ReportCommentary;
  readonly researchAndDevelopmentExpensesForTax: FinancialAmount;
  readonly reserves: ReportCommentary;
  readonly salaryExcessExpensesAmount: FinancialAmount;
  readonly taxRate: Scalars['Float']['output'];
  readonly taxableIncome: FinancialAmount;
  readonly untaxableGifts: ReportCommentary;
  readonly year: Scalars['Int']['output'];
};

/**  represent training fund */
export type TrainingFund = Fund & {
  readonly __typename?: 'TrainingFund';
  readonly id: Scalars['UUID']['output'];
  readonly name: Scalars['String']['output'];
};

/**  Represent a general transaction object  */
export type Transaction = {
  /**  link to the account  */
  readonly account: FinancialAccount;
  /**  the amount of the transaction  */
  readonly amount: FinancialAmount;
  /**  effective bank / card balance, after the transaction  */
  readonly balance: FinancialAmount;
  /**  containing charge ID  */
  readonly chargeId: Scalars['UUID']['output'];
  /**  calculated counterparty details for the charge  */
  readonly counterparty?: Maybe<FinancialEntity>;
  /**  when the initial transaction was created from the first event we found  */
  readonly createdAt: Scalars['DateTime']['output'];
  readonly cryptoExchangeRate?: Maybe<ConversionRate>;
  readonly debitExchangeRates?: Maybe<ExchangeRates>;
  /**  either credit or debit  */
  readonly direction: TransactionDirection;
  /**  debitDate  */
  readonly effectiveDate?: Maybe<Scalars['TimelessDate']['output']>;
  /**  eventDate  */
  readonly eventDate: Scalars['TimelessDate']['output'];
  readonly eventExchangeRates?: Maybe<ExchangeRates>;
  /**  debitTimeStamp  */
  readonly exactEffectiveDate?: Maybe<Scalars['DateTime']['output']>;
  readonly id: Scalars['UUID']['output'];
  /**  is this transaction a fee?  */
  readonly isFee?: Maybe<Scalars['Boolean']['output']>;
  /**  missing info suggestions data  */
  readonly missingInfoSuggestions?: Maybe<TransactionSuggestions>;
  /**  Source DB ID  */
  readonly referenceId: Scalars['String']['output'];
  /**  external key / identifier in the bank or card (אסמכתא)  */
  readonly referenceKey?: Maybe<Scalars['String']['output']>;
  /**  description of the transaction, as defined by the bank/card  */
  readonly sourceDescription: Scalars['String']['output'];
  /**  debitDate without user overrides and completions  */
  readonly sourceEffectiveDate?: Maybe<Scalars['TimelessDate']['output']>;
  /**  when the transaction was last updated  */
  readonly updatedAt: Scalars['DateTime']['output'];
};

export { TransactionDirection };

/**  represent transaction suggestions for missing info  */
export type TransactionSuggestions = {
  readonly __typename?: 'TransactionSuggestions';
  readonly business: FinancialEntity;
};

/**  represent transaction not (fully) categorized under business trips  */
export type UncategorizedTransaction = {
  readonly __typename?: 'UncategorizedTransaction';
  readonly categorizedAmount: FinancialAmount;
  readonly errors: ReadonlyArray<Scalars['String']['output']>;
  readonly transaction: Transaction;
};

/**  document that haven't yet been processed */
export type Unprocessed = Document & Linkable & {
  readonly __typename?: 'Unprocessed';
  readonly charge?: Maybe<Charge>;
  readonly documentType?: Maybe<DocumentType>;
  readonly file?: Maybe<Scalars['URL']['output']>;
  readonly id: Scalars['UUID']['output'];
  readonly image?: Maybe<Scalars['URL']['output']>;
  readonly isReviewed?: Maybe<Scalars['Boolean']['output']>;
};

/**  input for updateBusiness  */
export type UpdateBusinessInput = {
  readonly address?: InputMaybe<Scalars['String']['input']>;
  readonly country?: InputMaybe<Scalars['String']['input']>;
  readonly email?: InputMaybe<Scalars['String']['input']>;
  readonly exemptDealer?: InputMaybe<Scalars['Boolean']['input']>;
  readonly governmentId?: InputMaybe<Scalars['String']['input']>;
  readonly hebrewName?: InputMaybe<Scalars['String']['input']>;
  readonly name?: InputMaybe<Scalars['String']['input']>;
  readonly optionalVAT?: InputMaybe<Scalars['Boolean']['input']>;
  readonly phoneNumber?: InputMaybe<Scalars['String']['input']>;
  readonly sortCode?: InputMaybe<Scalars['Int']['input']>;
  readonly suggestions?: InputMaybe<SuggestionsInput>;
  readonly taxCategory?: InputMaybe<Scalars['UUID']['input']>;
  readonly website?: InputMaybe<Scalars['String']['input']>;
};

/**  result type for updateBusiness  */
export type UpdateBusinessResponse = CommonError | LtdFinancialEntity;

/**  the input for updating a business trip accommodation expense  */
export type UpdateBusinessTripAccommodationsExpenseInput = {
  readonly amount?: InputMaybe<Scalars['Float']['input']>;
  readonly attendeesStay: ReadonlyArray<BusinessTripAttendeeStayInput>;
  readonly businessTripId: Scalars['UUID']['input'];
  readonly country?: InputMaybe<Scalars['String']['input']>;
  readonly currency?: InputMaybe<Currency>;
  readonly date?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly employeeBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  readonly id: Scalars['UUID']['input'];
  readonly nightsCount?: InputMaybe<Scalars['Int']['input']>;
  readonly valueDate?: InputMaybe<Scalars['TimelessDate']['input']>;
};

/**  the input for updating a business trip car rental expense  */
export type UpdateBusinessTripCarRentalExpenseInput = {
  readonly amount?: InputMaybe<Scalars['Float']['input']>;
  readonly businessTripId: Scalars['UUID']['input'];
  readonly currency?: InputMaybe<Currency>;
  readonly date?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly days?: InputMaybe<Scalars['Int']['input']>;
  readonly employeeBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  readonly id: Scalars['UUID']['input'];
  readonly isFuelExpense?: InputMaybe<Scalars['Boolean']['input']>;
  readonly valueDate?: InputMaybe<Scalars['TimelessDate']['input']>;
};

/**  the input for updating a business trip flights expense  */
export type UpdateBusinessTripFlightsExpenseInput = {
  readonly amount?: InputMaybe<Scalars['Float']['input']>;
  readonly attendeeIds?: InputMaybe<ReadonlyArray<Scalars['UUID']['input']>>;
  readonly businessTripId: Scalars['UUID']['input'];
  readonly currency?: InputMaybe<Currency>;
  readonly date?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly employeeBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  readonly flightClass?: InputMaybe<FlightClass>;
  readonly id: Scalars['UUID']['input'];
  readonly path?: InputMaybe<ReadonlyArray<Scalars['String']['input']>>;
  readonly valueDate?: InputMaybe<Scalars['TimelessDate']['input']>;
};

/**  the input for updating a business trip  */
export type UpdateBusinessTripInput = {
  readonly destinationCode?: InputMaybe<Scalars['String']['input']>;
  readonly name?: InputMaybe<Scalars['String']['input']>;
  readonly tripPurpose?: InputMaybe<Scalars['String']['input']>;
};

/**  the input for updating a business trip other expense  */
export type UpdateBusinessTripOtherExpenseInput = {
  readonly amount?: InputMaybe<Scalars['Float']['input']>;
  readonly businessTripId: Scalars['UUID']['input'];
  readonly currency?: InputMaybe<Currency>;
  readonly date?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly deductibleExpense?: InputMaybe<Scalars['Boolean']['input']>;
  readonly description?: InputMaybe<Scalars['String']['input']>;
  readonly employeeBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  readonly id: Scalars['UUID']['input'];
  readonly valueDate?: InputMaybe<Scalars['TimelessDate']['input']>;
};

/**  the input for updating a business trip T&S expense  */
export type UpdateBusinessTripTravelAndSubsistenceExpenseInput = {
  readonly amount?: InputMaybe<Scalars['Float']['input']>;
  readonly businessTripId: Scalars['UUID']['input'];
  readonly currency?: InputMaybe<Currency>;
  readonly date?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly employeeBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  readonly expenseType?: InputMaybe<Scalars['String']['input']>;
  readonly id: Scalars['UUID']['input'];
  readonly valueDate?: InputMaybe<Scalars['TimelessDate']['input']>;
};

/**  input variables for updateCharge  */
export type UpdateChargeInput = {
  readonly accountantApproval?: InputMaybe<AccountantStatus>;
  readonly businessTripID?: InputMaybe<Scalars['UUID']['input']>;
  readonly counterpartyId?: InputMaybe<Scalars['UUID']['input']>;
  readonly defaultTaxCategoryID?: InputMaybe<Scalars['UUID']['input']>;
  readonly isConversion?: InputMaybe<Scalars['Boolean']['input']>;
  readonly isInvoicePaymentDifferentCurrency?: InputMaybe<Scalars['Boolean']['input']>;
  readonly isProperty?: InputMaybe<Scalars['Boolean']['input']>;
  readonly optionalVAT?: InputMaybe<Scalars['Boolean']['input']>;
  readonly ownerId?: InputMaybe<Scalars['UUID']['input']>;
  readonly tags?: InputMaybe<ReadonlyArray<TagInput>>;
  /**  user custom description  */
  readonly userDescription?: InputMaybe<Scalars['String']['input']>;
  readonly yearsOfRelevance?: InputMaybe<ReadonlyArray<YearOfRelevanceInput>>;
};

/**  result type for updateCharge  */
export type UpdateChargeResult = CommonError | UpdateChargeSuccessfulResult;

/**  successful result type for updateCharge  */
export type UpdateChargeSuccessfulResult = {
  readonly __typename?: 'UpdateChargeSuccessfulResult';
  readonly charge: Charge;
};

/**  input variables for updateDepreciationCategory  */
export type UpdateDepreciationCategoryInput = {
  readonly id: Scalars['UUID']['input'];
  readonly name?: InputMaybe<Scalars['String']['input']>;
  readonly percentage?: InputMaybe<Scalars['Float']['input']>;
};

/**  result type for updateDepreciationCategory  */
export type UpdateDepreciationCategoryResult = CommonError | DepreciationCategory;

/**  input variables for updateDepreciationRecord  */
export type UpdateDepreciationRecordInput = {
  readonly activationDate?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly amount?: InputMaybe<Scalars['Float']['input']>;
  readonly categoryId?: InputMaybe<Scalars['UUID']['input']>;
  readonly chargeId?: InputMaybe<Scalars['UUID']['input']>;
  readonly currency?: InputMaybe<Currency>;
  readonly id: Scalars['UUID']['input'];
  readonly type?: InputMaybe<DepreciationType>;
};

/**  result type for updateDepreciationRecord  */
export type UpdateDepreciationRecordResult = CommonError | DepreciationRecord;

/**  input variables for updateDocument  */
export type UpdateDocumentFieldsInput = {
  readonly amount?: InputMaybe<FinancialAmountInput>;
  readonly chargeId?: InputMaybe<Scalars['UUID']['input']>;
  readonly creditorId?: InputMaybe<Scalars['UUID']['input']>;
  readonly date?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly debtorId?: InputMaybe<Scalars['UUID']['input']>;
  readonly documentType?: InputMaybe<DocumentType>;
  readonly file?: InputMaybe<Scalars['URL']['input']>;
  readonly image?: InputMaybe<Scalars['URL']['input']>;
  readonly noVatAmount?: InputMaybe<Scalars['Float']['input']>;
  readonly serialNumber?: InputMaybe<Scalars['String']['input']>;
  readonly vat?: InputMaybe<FinancialAmountInput>;
  readonly vatReportDateOverride?: InputMaybe<Scalars['TimelessDate']['input']>;
};

/**  result type for updateCharge  */
export type UpdateDocumentResult = CommonError | UpdateDocumentSuccessfulResult;

/**  result type for updateDocument */
export type UpdateDocumentSuccessfulResult = {
  readonly __typename?: 'UpdateDocumentSuccessfulResult';
  readonly document?: Maybe<Document>;
};

/**  input variables for updateMiscExpense  */
export type UpdateMiscExpenseInput = {
  readonly amount?: InputMaybe<Scalars['Float']['input']>;
  readonly chargeId?: InputMaybe<Scalars['UUID']['input']>;
  readonly creditorId?: InputMaybe<Scalars['UUID']['input']>;
  readonly currency?: InputMaybe<Currency>;
  readonly debtorId?: InputMaybe<Scalars['UUID']['input']>;
  readonly description?: InputMaybe<Scalars['String']['input']>;
  readonly invoiceDate?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly valueDate?: InputMaybe<Scalars['DateTime']['input']>;
};

/**  result type for updateCharge  */
export type UpdateSalaryRecordResult = CommonError | UpdateSalaryRecordSuccessfulResult;

/**  result type for updateSalaryRecord */
export type UpdateSalaryRecordSuccessfulResult = {
  readonly __typename?: 'UpdateSalaryRecordSuccessfulResult';
  readonly salaryRecord: Salary;
};

/**  input variables for updateTag  */
export type UpdateTagFieldsInput = {
  readonly name?: InputMaybe<Scalars['String']['input']>;
  readonly parentId?: InputMaybe<Scalars['UUID']['input']>;
};

/**  input for updateTaxCategory  */
export type UpdateTaxCategoryInput = {
  readonly hashavshevetName?: InputMaybe<Scalars['String']['input']>;
  readonly name?: InputMaybe<Scalars['String']['input']>;
  readonly sortCode?: InputMaybe<Scalars['Int']['input']>;
};

/**  result type for updateBusiness  */
export type UpdateTaxCategoryResponse = CommonError | TaxCategory;

/**  input variables for updateTransaction  */
export type UpdateTransactionInput = {
  readonly chargeId?: InputMaybe<Scalars['UUID']['input']>;
  readonly counterpartyId?: InputMaybe<Scalars['UUID']['input']>;
  readonly effectiveDate?: InputMaybe<Scalars['TimelessDate']['input']>;
  readonly isFee?: InputMaybe<Scalars['Boolean']['input']>;
};

/**  result type for updateTransaction  */
export type UpdateTransactionResult = CommonError | CommonTransaction | ConversionTransaction;

/**  result type for uploadDocument  */
export type UploadDocumentResult = CommonError | UploadDocumentSuccessfulResult;

/**  result type for uploadDocument */
export type UploadDocumentSuccessfulResult = {
  readonly __typename?: 'UploadDocumentSuccessfulResult';
  readonly document?: Maybe<Document>;
};

/**  defines vacation days for salary record  */
export type VacationDays = {
  readonly __typename?: 'VacationDays';
  readonly added?: Maybe<Scalars['Float']['output']>;
  readonly balance?: Maybe<Scalars['Float']['output']>;
  readonly taken?: Maybe<Scalars['Float']['output']>;
};

/**  represent a validation data for missing info  */
export type ValidationData = {
  readonly __typename?: 'ValidationData';
  readonly balance?: Maybe<FinancialAmount>;
  readonly isValid: Scalars['Boolean']['output'];
  readonly missingInfo: ReadonlyArray<MissingChargeInfo>;
};

/**  input variables for vatReportRecords  */
export type VatReportFilter = {
  readonly chargesType?: InputMaybe<ChargeFilterType>;
  readonly financialEntityId: Scalars['UUID']['input'];
  readonly fromDate: Scalars['TimelessDate']['input'];
  readonly toDate: Scalars['TimelessDate']['input'];
};

/**  Vat report record  */
export type VatReportRecord = {
  readonly __typename?: 'VatReportRecord';
  readonly amount: FinancialAmount;
  readonly business?: Maybe<FinancialEntity>;
  readonly chargeAccountantStatus?: Maybe<AccountantStatus>;
  readonly chargeDate?: Maybe<Scalars['TimelessDate']['output']>;
  readonly chargeId: Scalars['UUID']['output'];
  readonly documentDate?: Maybe<Scalars['TimelessDate']['output']>;
  readonly documentId?: Maybe<Scalars['UUID']['output']>;
  readonly documentSerial?: Maybe<Scalars['String']['output']>;
  readonly foreignVat?: Maybe<FinancialAmount>;
  readonly foreignVatAfterDeduction?: Maybe<FinancialAmount>;
  readonly image?: Maybe<Scalars['String']['output']>;
  readonly localAmount?: Maybe<FinancialAmount>;
  readonly localVat?: Maybe<FinancialAmount>;
  readonly localVatAfterDeduction?: Maybe<FinancialAmount>;
  /**  Int value */
  readonly roundedLocalVatAfterDeduction?: Maybe<FinancialIntAmount>;
  readonly taxReducedForeignAmount?: Maybe<FinancialIntAmount>;
  readonly taxReducedLocalAmount?: Maybe<FinancialIntAmount>;
  readonly vatNumber?: Maybe<Scalars['String']['output']>;
};

/**  vat report result  */
export type VatReportResult = {
  readonly __typename?: 'VatReportResult';
  readonly businessTrips: ReadonlyArray<Charge>;
  readonly differentMonthDoc: ReadonlyArray<Charge>;
  readonly expenses: ReadonlyArray<VatReportRecord>;
  readonly income: ReadonlyArray<VatReportRecord>;
  readonly missingInfo: ReadonlyArray<Charge>;
};

/**  charge spread type  */
export type YearOfRelevance = {
  readonly __typename?: 'YearOfRelevance';
  readonly amount?: Maybe<Scalars['Float']['output']>;
  readonly year: Scalars['String']['output'];
};

/**  input variables for charge spread  */
export type YearOfRelevanceInput = {
  readonly amount?: InputMaybe<Scalars['Float']['input']>;
  readonly year: Scalars['TimelessDate']['input'];
};

/**  yearly ledger report  */
export type YearlyLedgerReport = {
  readonly __typename?: 'YearlyLedgerReport';
  readonly financialEntitiesInfo: ReadonlyArray<YearlyLedgerReportFinancialEntityInfo>;
  readonly id: Scalars['ID']['output'];
  readonly year: Scalars['Int']['output'];
};

/**  Vat report record  */
export type YearlyLedgerReportFinancialEntityInfo = {
  readonly __typename?: 'YearlyLedgerReportFinancialEntityInfo';
  readonly closingBalance: FinancialAmount;
  readonly entity: FinancialEntity;
  readonly openingBalance: FinancialAmount;
  readonly records: ReadonlyArray<SingleSidedLedgerRecord>;
  readonly totalCredit: FinancialAmount;
  readonly totalDebit: FinancialAmount;
};



export type ResolverTypeWrapper<T> = Promise<T> | T;


export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
  resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
};
export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<TResult, TParent, TContext, TArgs>;

export type ResolverFn<TResult, TParent, TContext, TArgs> = (
  parent: TParent,
  args: TArgs,
  context: TContext,
  info: GraphQLResolveInfo
) => Promise<TResult> | TResult;

export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (
  parent: TParent,
  args: TArgs,
  context: TContext,
  info: GraphQLResolveInfo
) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>;

export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (
  parent: TParent,
  args: TArgs,
  context: TContext,
  info: GraphQLResolveInfo
) => TResult | Promise<TResult>;

export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
  subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>;
  resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult }, TContext, TArgs>;
}

export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
  subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>;
  resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
}

export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> =
  | SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>
  | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;

export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> =
  | ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
  | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;

export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
  parent: TParent,
  context: TContext,
  info: GraphQLResolveInfo
) => Maybe<TTypes> | Promise<Maybe<TTypes>>;

export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;

export type NextResolverFn<T> = () => Promise<T>;

export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (
  next: NextResolverFn<TResult>,
  parent: TParent,
  args: TArgs,
  context: TContext,
  info: GraphQLResolveInfo
) => TResult | Promise<TResult>;

/** Mapping of union types */
export type ResolversUnionTypes<_RefType extends Record<string, unknown>> = {
  BusinessTransactionsFromLedgerRecordsResult: ( Omit<BusinessTransactionsFromLedgerRecordsSuccessfulResult, 'businessTransactions'> & { businessTransactions: ReadonlyArray<_RefType['BusinessTransaction']> } ) | ( CommonError );
  BusinessTransactionsSumFromLedgerRecordsResult: ( Omit<BusinessTransactionsSumFromLedgerRecordsSuccessfulResult, 'businessTransactionsSum'> & { businessTransactionsSum: ReadonlyArray<_RefType['BusinessTransactionSum']> } ) | ( CommonError );
  GeneratedLedgerRecords: ( CommonError ) | ( LedgerRecordsProto );
  InsertDepreciationCategoryResult: ( CommonError ) | ( IGetAllDepreciationCategoriesResult );
  InsertDepreciationRecordResult: ( CommonError ) | ( IGetDepreciationRecordsByIdsResult );
  InsertDocumentResult: ( CommonError ) | ( Omit<InsertDocumentSuccessfulResult, 'document'> & { document?: Maybe<_RefType['Document']> } );
  InsertSalaryRecordsResult: ( CommonError ) | ( Omit<InsertSalaryRecordsSuccessfulResult, 'salaryRecords'> & { salaryRecords: ReadonlyArray<_RefType['Salary']> } );
  MergeChargeResult: ( CommonError ) | ( Omit<MergeChargeSuccessfulResult, 'charge'> & { charge: _RefType['Charge'] } );
  UpdateBusinessResponse: ( CommonError ) | ( IGetBusinessesByIdsResult );
  UpdateChargeResult: ( CommonError ) | ( Omit<UpdateChargeSuccessfulResult, 'charge'> & { charge: _RefType['Charge'] } );
  UpdateDepreciationCategoryResult: ( CommonError ) | ( IGetAllDepreciationCategoriesResult );
  UpdateDepreciationRecordResult: ( CommonError ) | ( IGetDepreciationRecordsByIdsResult );
  UpdateDocumentResult: ( CommonError ) | ( Omit<UpdateDocumentSuccessfulResult, 'document'> & { document?: Maybe<_RefType['Document']> } );
  UpdateSalaryRecordResult: ( CommonError ) | ( Omit<UpdateSalaryRecordSuccessfulResult, 'salaryRecord'> & { salaryRecord: _RefType['Salary'] } );
  UpdateTaxCategoryResponse: ( CommonError ) | ( IGetAllTaxCategoriesResult );
  UpdateTransactionResult: ( CommonError ) | ( IGetTransactionsByIdsResult ) | ( IGetTransactionsByIdsResult );
  UploadDocumentResult: ( CommonError ) | ( Omit<UploadDocumentSuccessfulResult, 'document'> & { document?: Maybe<_RefType['Document']> } );
};

/** Mapping of interface types */
export type ResolversInterfaceTypes<_RefType extends Record<string, unknown>> = {
  Business: ( IGetBusinessesByIdsResult ) | ( IGetBusinessesByIdsResult );
  BusinessTripExpense: ( IGetBusinessTripsAccommodationsExpensesByIdsResult ) | ( IGetBusinessTripsCarRentalExpensesByIdsResult ) | ( IGetBusinessTripsFlightsExpensesByIdsResult ) | ( IGetBusinessTripsOtherExpensesByIdsResult ) | ( IGetBusinessTripsTravelAndSubsistenceExpensesByIdsResult );
  Charge: ( IGetChargesByIdsResult ) | ( IGetChargesByIdsResult ) | ( IGetChargesByIdsResult ) | ( IGetChargesByIdsResult ) | ( IGetChargesByIdsResult ) | ( IGetChargesByIdsResult ) | ( IGetChargesByIdsResult ) | ( IGetChargesByIdsResult ) | ( IGetChargesByIdsResult ) | ( IGetChargesByIdsResult );
  Document: ( IGetAllDocumentsResult ) | ( IGetAllDocumentsResult ) | ( IGetAllDocumentsResult ) | ( IGetAllDocumentsResult ) | ( IGetAllDocumentsResult ) | ( IGetAllDocumentsResult ) | ( IGetAllDocumentsResult );
  Error: ( CommonError );
  FinancialAccount: ( IGetFinancialAccountsByOwnerIdsResult ) | ( IGetFinancialAccountsByOwnerIdsResult ) | ( IGetFinancialAccountsByOwnerIdsResult );
  FinancialDocument: ( IGetAllDocumentsResult ) | ( IGetAllDocumentsResult ) | ( IGetAllDocumentsResult ) | ( IGetAllDocumentsResult ) | ( IGetAllDocumentsResult );
  FinancialEntity: ( IGetBusinessesByIdsResult ) | ( IGetBusinessesByIdsResult ) | ( IGetAllTaxCategoriesResult );
  Fund: ( PensionFund ) | ( TrainingFund );
  Linkable: ( IGetAllDocumentsResult ) | ( IGetAllDocumentsResult ) | ( IGetAllDocumentsResult ) | ( IGetAllDocumentsResult ) | ( IGetAllDocumentsResult ) | ( IGetAllDocumentsResult ) | ( IGetAllDocumentsResult );
  Transaction: ( IGetTransactionsByIdsResult ) | ( IGetTransactionsByIdsResult );
};

/** Mapping between all available schema types and the resolvers types */
export type ResolversTypes = {
  AccountantStatus: AccountantStatus;
  AddBusinessTripAccommodationsExpenseInput: AddBusinessTripAccommodationsExpenseInput;
  AddBusinessTripCarRentalExpenseInput: AddBusinessTripCarRentalExpenseInput;
  AddBusinessTripFlightsExpenseInput: AddBusinessTripFlightsExpenseInput;
  AddBusinessTripOtherExpenseInput: AddBusinessTripOtherExpenseInput;
  AddBusinessTripTravelAndSubsistenceExpenseInput: AddBusinessTripTravelAndSubsistenceExpenseInput;
  BankDepositCharge: ResolverTypeWrapper<IGetChargesByIdsResult>;
  BankFinancialAccount: ResolverTypeWrapper<IGetFinancialAccountsByOwnerIdsResult>;
  Boolean: ResolverTypeWrapper<Scalars['Boolean']['output']>;
  Business: ResolverTypeWrapper<IGetBusinessesByIdsResult>;
  BusinessTransaction: ResolverTypeWrapper<BusinessTransactionProto>;
  BusinessTransactionSum: ResolverTypeWrapper<RawBusinessTransactionsSum>;
  BusinessTransactionsFilter: BusinessTransactionsFilter;
  BusinessTransactionsFromLedgerRecordsResult: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['BusinessTransactionsFromLedgerRecordsResult']>;
  BusinessTransactionsFromLedgerRecordsSuccessfulResult: ResolverTypeWrapper<Omit<BusinessTransactionsFromLedgerRecordsSuccessfulResult, 'businessTransactions'> & { businessTransactions: ReadonlyArray<ResolversTypes['BusinessTransaction']> }>;
  BusinessTransactionsSumFromLedgerRecordsResult: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['BusinessTransactionsSumFromLedgerRecordsResult']>;
  BusinessTransactionsSumFromLedgerRecordsSuccessfulResult: ResolverTypeWrapper<Omit<BusinessTransactionsSumFromLedgerRecordsSuccessfulResult, 'businessTransactionsSum'> & { businessTransactionsSum: ReadonlyArray<ResolversTypes['BusinessTransactionSum']> }>;
  BusinessTrip: ResolverTypeWrapper<BusinessTripProto>;
  BusinessTripAccommodationExpense: ResolverTypeWrapper<IGetBusinessTripsAccommodationsExpensesByIdsResult>;
  BusinessTripAttendee: ResolverTypeWrapper<IGetBusinessTripsAttendeesByBusinessTripIdsResult>;
  BusinessTripAttendeeStay: ResolverTypeWrapper<Omit<BusinessTripAttendeeStay, 'attendee'> & { attendee: ResolversTypes['BusinessTripAttendee'] }>;
  BusinessTripAttendeeStayInput: BusinessTripAttendeeStayInput;
  BusinessTripAttendeeUpdateInput: BusinessTripAttendeeUpdateInput;
  BusinessTripCarRentalExpense: ResolverTypeWrapper<IGetBusinessTripsCarRentalExpensesByIdsResult>;
  BusinessTripCharge: ResolverTypeWrapper<IGetChargesByIdsResult>;
  BusinessTripExpense: ResolverTypeWrapper<ResolversInterfaceTypes<ResolversTypes>['BusinessTripExpense']>;
  BusinessTripExpenseCategories: BusinessTripExpenseCategories;
  BusinessTripFlightExpense: ResolverTypeWrapper<IGetBusinessTripsFlightsExpensesByIdsResult>;
  BusinessTripOtherExpense: ResolverTypeWrapper<IGetBusinessTripsOtherExpensesByIdsResult>;
  BusinessTripSummary: ResolverTypeWrapper<Omit<BusinessTripSummary, 'excessExpenditure' | 'rows'> & { excessExpenditure?: Maybe<ResolversTypes['FinancialAmount']>, rows: ReadonlyArray<ResolversTypes['BusinessTripSummaryRow']> }>;
  BusinessTripSummaryCategories: BusinessTripSummaryCategories;
  BusinessTripSummaryRow: ResolverTypeWrapper<Omit<BusinessTripSummaryRow, 'excessExpenditure' | 'maxTaxableForeignCurrency' | 'maxTaxableLocalCurrency' | 'taxableForeignCurrency' | 'taxableLocalCurrency' | 'totalForeignCurrency' | 'totalLocalCurrency'> & { excessExpenditure?: Maybe<ResolversTypes['FinancialAmount']>, maxTaxableForeignCurrency: ResolversTypes['FinancialAmount'], maxTaxableLocalCurrency?: Maybe<ResolversTypes['FinancialAmount']>, taxableForeignCurrency: ResolversTypes['FinancialAmount'], taxableLocalCurrency?: Maybe<ResolversTypes['FinancialAmount']>, totalForeignCurrency: ResolversTypes['FinancialAmount'], totalLocalCurrency?: Maybe<ResolversTypes['FinancialAmount']> }>;
  BusinessTripTravelAndSubsistenceExpense: ResolverTypeWrapper<IGetBusinessTripsTravelAndSubsistenceExpensesByIdsResult>;
  CardFinancialAccount: ResolverTypeWrapper<IGetFinancialAccountsByOwnerIdsResult>;
  CategorizeBusinessTripExpenseInput: CategorizeBusinessTripExpenseInput;
  CategorizeIntoExistingBusinessTripExpenseInput: CategorizeIntoExistingBusinessTripExpenseInput;
  Charge: ResolverTypeWrapper<ResolversInterfaceTypes<ResolversTypes>['Charge']>;
  ChargeFilter: ChargeFilter;
  ChargeFilterType: ChargeFilterType;
  ChargeMetadata: ResolverTypeWrapper<IGetChargesByIdsResult>;
  ChargeSortBy: ChargeSortBy;
  ChargeSortByField: ChargeSortByField;
  ChargeSuggestions: ResolverTypeWrapper<Omit<ChargeSuggestions, 'tags'> & { tags: ReadonlyArray<ResolversTypes['Tag']> }>;
  ChargesWithLedgerChangesResult: ResolverTypeWrapper<Omit<ChargesWithLedgerChangesResult, 'charge'> & { charge?: Maybe<ResolversTypes['Charge']> }>;
  CommonCharge: ResolverTypeWrapper<IGetChargesByIdsResult>;
  CommonError: ResolverTypeWrapper<CommonError>;
  CommonTransaction: ResolverTypeWrapper<IGetTransactionsByIdsResult>;
  ConversionCharge: ResolverTypeWrapper<IGetChargesByIdsResult>;
  ConversionRate: ResolverTypeWrapper<ConversionRate>;
  ConversionTransaction: ResolverTypeWrapper<IGetTransactionsByIdsResult>;
  ConversionTransactionType: ConversionTransactionType;
  CorporateTax: ResolverTypeWrapper<IGetCorporateTaxesByCorporateIdsResult>;
  CorporateTaxRule: ResolverTypeWrapper<CorporateTaxRule>;
  CorporateTaxRulePercentage: ResolverTypeWrapper<CorporateTaxRulePercentage>;
  CorporateTaxRulingComplianceReport: ResolverTypeWrapper<CorporateTaxRulingComplianceReportProto>;
  CorporateTaxRulingComplianceReportDifferences: ResolverTypeWrapper<Omit<CorporateTaxRulingComplianceReportDifferences, 'businessTripRndExpenses' | 'foreignDevelopmentExpenses' | 'localDevelopmentExpenses' | 'researchAndDevelopmentExpenses' | 'totalIncome'> & { businessTripRndExpenses?: Maybe<ResolversTypes['FinancialAmount']>, foreignDevelopmentExpenses?: Maybe<ResolversTypes['FinancialAmount']>, localDevelopmentExpenses?: Maybe<ResolversTypes['FinancialAmount']>, researchAndDevelopmentExpenses?: Maybe<ResolversTypes['FinancialAmount']>, totalIncome?: Maybe<ResolversTypes['FinancialAmount']> }>;
  Country: ResolverTypeWrapper<IGetAllCountriesResult>;
  CreditInvoice: ResolverTypeWrapper<IGetAllDocumentsResult>;
  CreditcardBankCharge: ResolverTypeWrapper<IGetChargesByIdsResult>;
  CryptoWalletFinancialAccount: ResolverTypeWrapper<IGetFinancialAccountsByOwnerIdsResult>;
  Currency: Currency;
  DateRange: ResolverTypeWrapper<DateRange>;
  DateTime: ResolverTypeWrapper<Scalars['DateTime']['output']>;
  DeleteBusinessTripAttendeeInput: DeleteBusinessTripAttendeeInput;
  DepreciationCategory: ResolverTypeWrapper<IGetAllDepreciationCategoriesResult>;
  DepreciationRecord: ResolverTypeWrapper<IGetDepreciationRecordsByIdsResult>;
  DepreciationType: DepreciationType;
  DividendCharge: ResolverTypeWrapper<IGetChargesByIdsResult>;
  DividendMock: ResolverTypeWrapper<Scalars['DividendMock']['output']>;
  Document: ResolverTypeWrapper<ResolversInterfaceTypes<ResolversTypes>['Document']>;
  DocumentSuggestions: ResolverTypeWrapper<DocumentSuggestionsProto>;
  DocumentType: DocumentType;
  DocumentsFilters: DocumentsFilters;
  DynamicReportInfo: ResolverTypeWrapper<IGetTemplateResult>;
  DynamicReportNode: ResolverTypeWrapper<DynamicReportNode>;
  DynamicReportNodeData: ResolverTypeWrapper<DynamicReportNodeData>;
  Employee: ResolverTypeWrapper<Employee>;
  Error: ResolverTypeWrapper<ResolversInterfaceTypes<ResolversTypes>['Error']>;
  ExchangeRates: ResolverTypeWrapper<TimelessDateString>;
  FileScalar: ResolverTypeWrapper<Scalars['FileScalar']['output']>;
  FinancialAccount: ResolverTypeWrapper<ResolversInterfaceTypes<ResolversTypes>['FinancialAccount']>;
  FinancialAmount: ResolverTypeWrapper<FinancialAmount>;
  FinancialAmountInput: FinancialAmountInput;
  FinancialCharge: ResolverTypeWrapper<IGetChargesByIdsResult>;
  FinancialDocument: ResolverTypeWrapper<ResolversInterfaceTypes<ResolversTypes>['FinancialDocument']>;
  FinancialEntity: ResolverTypeWrapper<IGetFinancialEntitiesByIdsResult>;
  FinancialEntityType: FinancialEntityType;
  FinancialIntAmount: ResolverTypeWrapper<FinancialIntAmount>;
  FlagForeignFeeTransactionsResult: ResolverTypeWrapper<Omit<FlagForeignFeeTransactionsResult, 'transactions'> & { transactions?: Maybe<ReadonlyArray<ResolversTypes['Transaction']>> }>;
  FlightClass: FlightClass;
  Float: ResolverTypeWrapper<Scalars['Float']['output']>;
  ForeignCurrencySum: ResolverTypeWrapper<Omit<ForeignCurrencySum, 'credit' | 'debit' | 'total'> & { credit: ResolversTypes['FinancialAmount'], debit: ResolversTypes['FinancialAmount'], total: ResolversTypes['FinancialAmount'] }>;
  Fund: ResolverTypeWrapper<ResolversInterfaceTypes<ResolversTypes>['Fund']>;
  GenerateMonthlyClientDocumentsResult: ResolverTypeWrapper<GenerateMonthlyClientDocumentsResult>;
  GeneratedLedgerRecords: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['GeneratedLedgerRecords']>;
  ID: ResolverTypeWrapper<Scalars['ID']['output']>;
  IncomeExpenseChart: ResolverTypeWrapper<Omit<IncomeExpenseChart, 'monthlyData'> & { monthlyData: ReadonlyArray<ResolversTypes['IncomeExpenseChartMonthData']> }>;
  IncomeExpenseChartFilters: IncomeExpenseChartFilters;
  IncomeExpenseChartMonthData: ResolverTypeWrapper<MonthDataProto>;
  InsertBusinessTripAttendeeInput: InsertBusinessTripAttendeeInput;
  InsertBusinessTripInput: InsertBusinessTripInput;
  InsertDepreciationCategoryInput: InsertDepreciationCategoryInput;
  InsertDepreciationCategoryResult: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['InsertDepreciationCategoryResult']>;
  InsertDepreciationRecordInput: InsertDepreciationRecordInput;
  InsertDepreciationRecordResult: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['InsertDepreciationRecordResult']>;
  InsertDocumentInput: InsertDocumentInput;
  InsertDocumentResult: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['InsertDocumentResult']>;
  InsertDocumentSuccessfulResult: ResolverTypeWrapper<Omit<InsertDocumentSuccessfulResult, 'document'> & { document?: Maybe<ResolversTypes['Document']> }>;
  InsertMiscExpenseInput: InsertMiscExpenseInput;
  InsertNewBusinessInput: InsertNewBusinessInput;
  InsertSalaryRecordsResult: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['InsertSalaryRecordsResult']>;
  InsertSalaryRecordsSuccessfulResult: ResolverTypeWrapper<Omit<InsertSalaryRecordsSuccessfulResult, 'salaryRecords'> & { salaryRecords: ReadonlyArray<ResolversTypes['Salary']> }>;
  InsertTaxCategoryInput: InsertTaxCategoryInput;
  Int: ResolverTypeWrapper<Scalars['Int']['output']>;
  InternalTransferCharge: ResolverTypeWrapper<IGetChargesByIdsResult>;
  Invoice: ResolverTypeWrapper<IGetAllDocumentsResult>;
  InvoiceReceipt: ResolverTypeWrapper<IGetAllDocumentsResult>;
  Ledger: ResolverTypeWrapper<LedgerRecordsProto>;
  LedgerBalanceInfo: ResolverTypeWrapper<Omit<LedgerBalanceInfo, 'unbalancedEntities'> & { unbalancedEntities: ReadonlyArray<ResolversTypes['LedgerBalanceUnbalancedEntity']> }>;
  LedgerBalanceUnbalancedEntity: ResolverTypeWrapper<LedgerBalanceUnbalancedEntityProto>;
  LedgerRecord: ResolverTypeWrapper<IGetLedgerRecordsByChargesIdsResult>;
  LedgerValidation: ResolverTypeWrapper<Omit<LedgerValidation, 'differences'> & { differences: ReadonlyArray<ResolversTypes['LedgerRecord']> }>;
  LedgerValidationStatus: LedgerValidationStatus;
  Linkable: ResolverTypeWrapper<ResolversInterfaceTypes<ResolversTypes>['Linkable']>;
  LtdFinancialEntity: ResolverTypeWrapper<IGetBusinessesByIdsResult>;
  MergeChargeResult: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['MergeChargeResult']>;
  MergeChargeSuccessfulResult: ResolverTypeWrapper<Omit<MergeChargeSuccessfulResult, 'charge'> & { charge: ResolversTypes['Charge'] }>;
  MergeChargesByTransactionReferenceResult: ResolverTypeWrapper<Omit<MergeChargesByTransactionReferenceResult, 'charges'> & { charges?: Maybe<ReadonlyArray<ResolversTypes['Charge']>> }>;
  MiscExpense: ResolverTypeWrapper<IGetExpensesByChargeIdsResult>;
  MissingChargeInfo: MissingChargeInfo;
  MonthlyVatCharge: ResolverTypeWrapper<IGetChargesByIdsResult>;
  Mutation: ResolverTypeWrapper<{}>;
  OtherDocument: ResolverTypeWrapper<IGetAllDocumentsResult>;
  PCNFileResult: ResolverTypeWrapper<PcnFileResult>;
  PCNOptionsInput: PcnOptionsInput;
  PageInfo: ResolverTypeWrapper<PageInfo>;
  PaginatedBusinesses: ResolverTypeWrapper<Omit<PaginatedBusinesses, 'nodes'> & { nodes: ReadonlyArray<ResolversTypes['Business']> }>;
  PaginatedCharges: ResolverTypeWrapper<Omit<PaginatedCharges, 'nodes'> & { nodes: ReadonlyArray<ResolversTypes['Charge']> }>;
  PaginatedFinancialEntities: ResolverTypeWrapper<Omit<PaginatedFinancialEntities, 'nodes'> & { nodes: ReadonlyArray<ResolversTypes['FinancialEntity']> }>;
  PensionFund: ResolverTypeWrapper<PensionFund>;
  PersonalFinancialEntity: ResolverTypeWrapper<IGetBusinessesByIdsResult>;
  ProfitAndLossReport: ResolverTypeWrapper<Omit<ProfitAndLossReport, 'reference' | 'report'> & { reference: ReadonlyArray<ResolversTypes['ProfitAndLossReportYear']>, report: ResolversTypes['ProfitAndLossReportYear'] }>;
  ProfitAndLossReportYear: ResolverTypeWrapper<ProfitAndLossReportYearProto>;
  Proforma: ResolverTypeWrapper<IGetAllDocumentsResult>;
  Query: ResolverTypeWrapper<{}>;
  Rate: ResolverTypeWrapper<Scalars['Rate']['output']>;
  Receipt: ResolverTypeWrapper<IGetAllDocumentsResult>;
  ReportCommentary: ResolverTypeWrapper<Omit<ReportCommentary, 'amount' | 'records'> & { amount: ResolversTypes['FinancialAmount'], records: ReadonlyArray<ResolversTypes['ReportCommentaryRecord']> }>;
  ReportCommentaryRecord: ResolverTypeWrapper<CommentaryRecordProto>;
  ReportCommentarySubRecord: ResolverTypeWrapper<CommentarySubRecordProto>;
  Role: Role;
  Salary: ResolverTypeWrapper<IGetAllSalaryRecordsResult>;
  SalaryCharge: ResolverTypeWrapper<IGetChargesByIdsResult>;
  SalaryRecordEditInput: SalaryRecordEditInput;
  SalaryRecordInput: SalaryRecordInput;
  SicknessDays: ResolverTypeWrapper<SicknessDays>;
  SingleSidedLedgerRecord: ResolverTypeWrapper<Omit<SingleSidedLedgerRecord, 'amount' | 'counterParty'> & { amount: ResolversTypes['FinancialAmount'], counterParty?: Maybe<ResolversTypes['FinancialEntity']> }>;
  SortCode: ResolverTypeWrapper<IGetSortCodesByIdsResult>;
  String: ResolverTypeWrapper<Scalars['String']['output']>;
  Suggestions: ResolverTypeWrapper<Omit<Suggestions, 'tags'> & { tags: ReadonlyArray<ResolversTypes['Tag']> }>;
  SuggestionsInput: SuggestionsInput;
  Tag: ResolverTypeWrapper<IGetAllTagsResult>;
  TagInput: TagInput;
  TaxCategory: ResolverTypeWrapper<IGetAllTaxCategoriesResult>;
  TaxReport: ResolverTypeWrapper<Omit<TaxReport, 'reference' | 'report'> & { reference: ReadonlyArray<ResolversTypes['TaxReportYear']>, report: ResolversTypes['TaxReportYear'] }>;
  TaxReportYear: ResolverTypeWrapper<TaxReportYearProto>;
  TimelessDate: ResolverTypeWrapper<Scalars['TimelessDate']['output']>;
  TrainingFund: ResolverTypeWrapper<TrainingFund>;
  Transaction: ResolverTypeWrapper<ResolversInterfaceTypes<ResolversTypes>['Transaction']>;
  TransactionDirection: TransactionDirection;
  TransactionSuggestions: ResolverTypeWrapper<Omit<TransactionSuggestions, 'business'> & { business: ResolversTypes['FinancialEntity'] }>;
  URL: ResolverTypeWrapper<Scalars['URL']['output']>;
  UUID: ResolverTypeWrapper<Scalars['UUID']['output']>;
  UncategorizedTransaction: ResolverTypeWrapper<Omit<UncategorizedTransaction, 'categorizedAmount' | 'transaction'> & { categorizedAmount: ResolversTypes['FinancialAmount'], transaction: ResolversTypes['Transaction'] }>;
  Unprocessed: ResolverTypeWrapper<IGetAllDocumentsResult>;
  UpdateBusinessInput: UpdateBusinessInput;
  UpdateBusinessResponse: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['UpdateBusinessResponse']>;
  UpdateBusinessTripAccommodationsExpenseInput: UpdateBusinessTripAccommodationsExpenseInput;
  UpdateBusinessTripCarRentalExpenseInput: UpdateBusinessTripCarRentalExpenseInput;
  UpdateBusinessTripFlightsExpenseInput: UpdateBusinessTripFlightsExpenseInput;
  UpdateBusinessTripInput: UpdateBusinessTripInput;
  UpdateBusinessTripOtherExpenseInput: UpdateBusinessTripOtherExpenseInput;
  UpdateBusinessTripTravelAndSubsistenceExpenseInput: UpdateBusinessTripTravelAndSubsistenceExpenseInput;
  UpdateChargeInput: UpdateChargeInput;
  UpdateChargeResult: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['UpdateChargeResult']>;
  UpdateChargeSuccessfulResult: ResolverTypeWrapper<Omit<UpdateChargeSuccessfulResult, 'charge'> & { charge: ResolversTypes['Charge'] }>;
  UpdateDepreciationCategoryInput: UpdateDepreciationCategoryInput;
  UpdateDepreciationCategoryResult: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['UpdateDepreciationCategoryResult']>;
  UpdateDepreciationRecordInput: UpdateDepreciationRecordInput;
  UpdateDepreciationRecordResult: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['UpdateDepreciationRecordResult']>;
  UpdateDocumentFieldsInput: UpdateDocumentFieldsInput;
  UpdateDocumentResult: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['UpdateDocumentResult']>;
  UpdateDocumentSuccessfulResult: ResolverTypeWrapper<Omit<UpdateDocumentSuccessfulResult, 'document'> & { document?: Maybe<ResolversTypes['Document']> }>;
  UpdateMiscExpenseInput: UpdateMiscExpenseInput;
  UpdateSalaryRecordResult: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['UpdateSalaryRecordResult']>;
  UpdateSalaryRecordSuccessfulResult: ResolverTypeWrapper<Omit<UpdateSalaryRecordSuccessfulResult, 'salaryRecord'> & { salaryRecord: ResolversTypes['Salary'] }>;
  UpdateTagFieldsInput: UpdateTagFieldsInput;
  UpdateTaxCategoryInput: UpdateTaxCategoryInput;
  UpdateTaxCategoryResponse: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['UpdateTaxCategoryResponse']>;
  UpdateTransactionInput: UpdateTransactionInput;
  UpdateTransactionResult: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['UpdateTransactionResult']>;
  UploadDocumentResult: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['UploadDocumentResult']>;
  UploadDocumentSuccessfulResult: ResolverTypeWrapper<Omit<UploadDocumentSuccessfulResult, 'document'> & { document?: Maybe<ResolversTypes['Document']> }>;
  VacationDays: ResolverTypeWrapper<VacationDays>;
  ValidationData: ResolverTypeWrapper<Omit<ValidationData, 'balance'> & { balance?: Maybe<ResolversTypes['FinancialAmount']> }>;
  VatMock: ResolverTypeWrapper<Scalars['VatMock']['output']>;
  VatReportFilter: VatReportFilter;
  VatReportRecord: ResolverTypeWrapper<RawVatReportRecord>;
  VatReportResult: ResolverTypeWrapper<Omit<VatReportResult, 'businessTrips' | 'differentMonthDoc' | 'expenses' | 'income' | 'missingInfo'> & { businessTrips: ReadonlyArray<ResolversTypes['Charge']>, differentMonthDoc: ReadonlyArray<ResolversTypes['Charge']>, expenses: ReadonlyArray<ResolversTypes['VatReportRecord']>, income: ReadonlyArray<ResolversTypes['VatReportRecord']>, missingInfo: ReadonlyArray<ResolversTypes['Charge']> }>;
  YearOfRelevance: ResolverTypeWrapper<YearOfRelevance>;
  YearOfRelevanceInput: YearOfRelevanceInput;
  YearlyLedgerReport: ResolverTypeWrapper<Omit<YearlyLedgerReport, 'financialEntitiesInfo'> & { financialEntitiesInfo: ReadonlyArray<ResolversTypes['YearlyLedgerReportFinancialEntityInfo']> }>;
  YearlyLedgerReportFinancialEntityInfo: ResolverTypeWrapper<Omit<YearlyLedgerReportFinancialEntityInfo, 'closingBalance' | 'entity' | 'openingBalance' | 'records' | 'totalCredit' | 'totalDebit'> & { closingBalance: ResolversTypes['FinancialAmount'], entity: ResolversTypes['FinancialEntity'], openingBalance: ResolversTypes['FinancialAmount'], records: ReadonlyArray<ResolversTypes['SingleSidedLedgerRecord']>, totalCredit: ResolversTypes['FinancialAmount'], totalDebit: ResolversTypes['FinancialAmount'] }>;
};

/** Mapping between all available schema types and the resolvers parents */
export type ResolversParentTypes = {
  AddBusinessTripAccommodationsExpenseInput: AddBusinessTripAccommodationsExpenseInput;
  AddBusinessTripCarRentalExpenseInput: AddBusinessTripCarRentalExpenseInput;
  AddBusinessTripFlightsExpenseInput: AddBusinessTripFlightsExpenseInput;
  AddBusinessTripOtherExpenseInput: AddBusinessTripOtherExpenseInput;
  AddBusinessTripTravelAndSubsistenceExpenseInput: AddBusinessTripTravelAndSubsistenceExpenseInput;
  BankDepositCharge: IGetChargesByIdsResult;
  BankFinancialAccount: IGetFinancialAccountsByOwnerIdsResult;
  Boolean: Scalars['Boolean']['output'];
  Business: IGetBusinessesByIdsResult;
  BusinessTransaction: BusinessTransactionProto;
  BusinessTransactionSum: RawBusinessTransactionsSum;
  BusinessTransactionsFilter: BusinessTransactionsFilter;
  BusinessTransactionsFromLedgerRecordsResult: ResolversUnionTypes<ResolversParentTypes>['BusinessTransactionsFromLedgerRecordsResult'];
  BusinessTransactionsFromLedgerRecordsSuccessfulResult: Omit<BusinessTransactionsFromLedgerRecordsSuccessfulResult, 'businessTransactions'> & { businessTransactions: ReadonlyArray<ResolversParentTypes['BusinessTransaction']> };
  BusinessTransactionsSumFromLedgerRecordsResult: ResolversUnionTypes<ResolversParentTypes>['BusinessTransactionsSumFromLedgerRecordsResult'];
  BusinessTransactionsSumFromLedgerRecordsSuccessfulResult: Omit<BusinessTransactionsSumFromLedgerRecordsSuccessfulResult, 'businessTransactionsSum'> & { businessTransactionsSum: ReadonlyArray<ResolversParentTypes['BusinessTransactionSum']> };
  BusinessTrip: BusinessTripProto;
  BusinessTripAccommodationExpense: IGetBusinessTripsAccommodationsExpensesByIdsResult;
  BusinessTripAttendee: IGetBusinessTripsAttendeesByBusinessTripIdsResult;
  BusinessTripAttendeeStay: Omit<BusinessTripAttendeeStay, 'attendee'> & { attendee: ResolversParentTypes['BusinessTripAttendee'] };
  BusinessTripAttendeeStayInput: BusinessTripAttendeeStayInput;
  BusinessTripAttendeeUpdateInput: BusinessTripAttendeeUpdateInput;
  BusinessTripCarRentalExpense: IGetBusinessTripsCarRentalExpensesByIdsResult;
  BusinessTripCharge: IGetChargesByIdsResult;
  BusinessTripExpense: ResolversInterfaceTypes<ResolversParentTypes>['BusinessTripExpense'];
  BusinessTripFlightExpense: IGetBusinessTripsFlightsExpensesByIdsResult;
  BusinessTripOtherExpense: IGetBusinessTripsOtherExpensesByIdsResult;
  BusinessTripSummary: Omit<BusinessTripSummary, 'excessExpenditure' | 'rows'> & { excessExpenditure?: Maybe<ResolversParentTypes['FinancialAmount']>, rows: ReadonlyArray<ResolversParentTypes['BusinessTripSummaryRow']> };
  BusinessTripSummaryRow: Omit<BusinessTripSummaryRow, 'excessExpenditure' | 'maxTaxableForeignCurrency' | 'maxTaxableLocalCurrency' | 'taxableForeignCurrency' | 'taxableLocalCurrency' | 'totalForeignCurrency' | 'totalLocalCurrency'> & { excessExpenditure?: Maybe<ResolversParentTypes['FinancialAmount']>, maxTaxableForeignCurrency: ResolversParentTypes['FinancialAmount'], maxTaxableLocalCurrency?: Maybe<ResolversParentTypes['FinancialAmount']>, taxableForeignCurrency: ResolversParentTypes['FinancialAmount'], taxableLocalCurrency?: Maybe<ResolversParentTypes['FinancialAmount']>, totalForeignCurrency: ResolversParentTypes['FinancialAmount'], totalLocalCurrency?: Maybe<ResolversParentTypes['FinancialAmount']> };
  BusinessTripTravelAndSubsistenceExpense: IGetBusinessTripsTravelAndSubsistenceExpensesByIdsResult;
  CardFinancialAccount: IGetFinancialAccountsByOwnerIdsResult;
  CategorizeBusinessTripExpenseInput: CategorizeBusinessTripExpenseInput;
  CategorizeIntoExistingBusinessTripExpenseInput: CategorizeIntoExistingBusinessTripExpenseInput;
  Charge: ResolversInterfaceTypes<ResolversParentTypes>['Charge'];
  ChargeFilter: ChargeFilter;
  ChargeMetadata: IGetChargesByIdsResult;
  ChargeSortBy: ChargeSortBy;
  ChargeSuggestions: Omit<ChargeSuggestions, 'tags'> & { tags: ReadonlyArray<ResolversParentTypes['Tag']> };
  ChargesWithLedgerChangesResult: Omit<ChargesWithLedgerChangesResult, 'charge'> & { charge?: Maybe<ResolversParentTypes['Charge']> };
  CommonCharge: IGetChargesByIdsResult;
  CommonError: CommonError;
  CommonTransaction: IGetTransactionsByIdsResult;
  ConversionCharge: IGetChargesByIdsResult;
  ConversionRate: ConversionRate;
  ConversionTransaction: IGetTransactionsByIdsResult;
  CorporateTax: IGetCorporateTaxesByCorporateIdsResult;
  CorporateTaxRule: CorporateTaxRule;
  CorporateTaxRulePercentage: CorporateTaxRulePercentage;
  CorporateTaxRulingComplianceReport: CorporateTaxRulingComplianceReportProto;
  CorporateTaxRulingComplianceReportDifferences: Omit<CorporateTaxRulingComplianceReportDifferences, 'businessTripRndExpenses' | 'foreignDevelopmentExpenses' | 'localDevelopmentExpenses' | 'researchAndDevelopmentExpenses' | 'totalIncome'> & { businessTripRndExpenses?: Maybe<ResolversParentTypes['FinancialAmount']>, foreignDevelopmentExpenses?: Maybe<ResolversParentTypes['FinancialAmount']>, localDevelopmentExpenses?: Maybe<ResolversParentTypes['FinancialAmount']>, researchAndDevelopmentExpenses?: Maybe<ResolversParentTypes['FinancialAmount']>, totalIncome?: Maybe<ResolversParentTypes['FinancialAmount']> };
  Country: IGetAllCountriesResult;
  CreditInvoice: IGetAllDocumentsResult;
  CreditcardBankCharge: IGetChargesByIdsResult;
  CryptoWalletFinancialAccount: IGetFinancialAccountsByOwnerIdsResult;
  DateRange: DateRange;
  DateTime: Scalars['DateTime']['output'];
  DeleteBusinessTripAttendeeInput: DeleteBusinessTripAttendeeInput;
  DepreciationCategory: IGetAllDepreciationCategoriesResult;
  DepreciationRecord: IGetDepreciationRecordsByIdsResult;
  DividendCharge: IGetChargesByIdsResult;
  DividendMock: Scalars['DividendMock']['output'];
  Document: ResolversInterfaceTypes<ResolversParentTypes>['Document'];
  DocumentSuggestions: DocumentSuggestionsProto;
  DocumentsFilters: DocumentsFilters;
  DynamicReportInfo: IGetTemplateResult;
  DynamicReportNode: DynamicReportNode;
  DynamicReportNodeData: DynamicReportNodeData;
  Employee: Employee;
  Error: ResolversInterfaceTypes<ResolversParentTypes>['Error'];
  ExchangeRates: TimelessDateString;
  FileScalar: Scalars['FileScalar']['output'];
  FinancialAccount: ResolversInterfaceTypes<ResolversParentTypes>['FinancialAccount'];
  FinancialAmount: FinancialAmount;
  FinancialAmountInput: FinancialAmountInput;
  FinancialCharge: IGetChargesByIdsResult;
  FinancialDocument: ResolversInterfaceTypes<ResolversParentTypes>['FinancialDocument'];
  FinancialEntity: IGetFinancialEntitiesByIdsResult;
  FinancialIntAmount: FinancialIntAmount;
  FlagForeignFeeTransactionsResult: Omit<FlagForeignFeeTransactionsResult, 'transactions'> & { transactions?: Maybe<ReadonlyArray<ResolversParentTypes['Transaction']>> };
  Float: Scalars['Float']['output'];
  ForeignCurrencySum: Omit<ForeignCurrencySum, 'credit' | 'debit' | 'total'> & { credit: ResolversParentTypes['FinancialAmount'], debit: ResolversParentTypes['FinancialAmount'], total: ResolversParentTypes['FinancialAmount'] };
  Fund: ResolversInterfaceTypes<ResolversParentTypes>['Fund'];
  GenerateMonthlyClientDocumentsResult: GenerateMonthlyClientDocumentsResult;
  GeneratedLedgerRecords: ResolversUnionTypes<ResolversParentTypes>['GeneratedLedgerRecords'];
  ID: Scalars['ID']['output'];
  IncomeExpenseChart: Omit<IncomeExpenseChart, 'monthlyData'> & { monthlyData: ReadonlyArray<ResolversParentTypes['IncomeExpenseChartMonthData']> };
  IncomeExpenseChartFilters: IncomeExpenseChartFilters;
  IncomeExpenseChartMonthData: MonthDataProto;
  InsertBusinessTripAttendeeInput: InsertBusinessTripAttendeeInput;
  InsertBusinessTripInput: InsertBusinessTripInput;
  InsertDepreciationCategoryInput: InsertDepreciationCategoryInput;
  InsertDepreciationCategoryResult: ResolversUnionTypes<ResolversParentTypes>['InsertDepreciationCategoryResult'];
  InsertDepreciationRecordInput: InsertDepreciationRecordInput;
  InsertDepreciationRecordResult: ResolversUnionTypes<ResolversParentTypes>['InsertDepreciationRecordResult'];
  InsertDocumentInput: InsertDocumentInput;
  InsertDocumentResult: ResolversUnionTypes<ResolversParentTypes>['InsertDocumentResult'];
  InsertDocumentSuccessfulResult: Omit<InsertDocumentSuccessfulResult, 'document'> & { document?: Maybe<ResolversParentTypes['Document']> };
  InsertMiscExpenseInput: InsertMiscExpenseInput;
  InsertNewBusinessInput: InsertNewBusinessInput;
  InsertSalaryRecordsResult: ResolversUnionTypes<ResolversParentTypes>['InsertSalaryRecordsResult'];
  InsertSalaryRecordsSuccessfulResult: Omit<InsertSalaryRecordsSuccessfulResult, 'salaryRecords'> & { salaryRecords: ReadonlyArray<ResolversParentTypes['Salary']> };
  InsertTaxCategoryInput: InsertTaxCategoryInput;
  Int: Scalars['Int']['output'];
  InternalTransferCharge: IGetChargesByIdsResult;
  Invoice: IGetAllDocumentsResult;
  InvoiceReceipt: IGetAllDocumentsResult;
  Ledger: LedgerRecordsProto;
  LedgerBalanceInfo: Omit<LedgerBalanceInfo, 'unbalancedEntities'> & { unbalancedEntities: ReadonlyArray<ResolversParentTypes['LedgerBalanceUnbalancedEntity']> };
  LedgerBalanceUnbalancedEntity: LedgerBalanceUnbalancedEntityProto;
  LedgerRecord: IGetLedgerRecordsByChargesIdsResult;
  LedgerValidation: Omit<LedgerValidation, 'differences'> & { differences: ReadonlyArray<ResolversParentTypes['LedgerRecord']> };
  Linkable: ResolversInterfaceTypes<ResolversParentTypes>['Linkable'];
  LtdFinancialEntity: IGetBusinessesByIdsResult;
  MergeChargeResult: ResolversUnionTypes<ResolversParentTypes>['MergeChargeResult'];
  MergeChargeSuccessfulResult: Omit<MergeChargeSuccessfulResult, 'charge'> & { charge: ResolversParentTypes['Charge'] };
  MergeChargesByTransactionReferenceResult: Omit<MergeChargesByTransactionReferenceResult, 'charges'> & { charges?: Maybe<ReadonlyArray<ResolversParentTypes['Charge']>> };
  MiscExpense: IGetExpensesByChargeIdsResult;
  MonthlyVatCharge: IGetChargesByIdsResult;
  Mutation: {};
  OtherDocument: IGetAllDocumentsResult;
  PCNFileResult: PcnFileResult;
  PCNOptionsInput: PcnOptionsInput;
  PageInfo: PageInfo;
  PaginatedBusinesses: Omit<PaginatedBusinesses, 'nodes'> & { nodes: ReadonlyArray<ResolversParentTypes['Business']> };
  PaginatedCharges: Omit<PaginatedCharges, 'nodes'> & { nodes: ReadonlyArray<ResolversParentTypes['Charge']> };
  PaginatedFinancialEntities: Omit<PaginatedFinancialEntities, 'nodes'> & { nodes: ReadonlyArray<ResolversParentTypes['FinancialEntity']> };
  PensionFund: PensionFund;
  PersonalFinancialEntity: IGetBusinessesByIdsResult;
  ProfitAndLossReport: Omit<ProfitAndLossReport, 'reference' | 'report'> & { reference: ReadonlyArray<ResolversParentTypes['ProfitAndLossReportYear']>, report: ResolversParentTypes['ProfitAndLossReportYear'] };
  ProfitAndLossReportYear: ProfitAndLossReportYearProto;
  Proforma: IGetAllDocumentsResult;
  Query: {};
  Rate: Scalars['Rate']['output'];
  Receipt: IGetAllDocumentsResult;
  ReportCommentary: Omit<ReportCommentary, 'amount' | 'records'> & { amount: ResolversParentTypes['FinancialAmount'], records: ReadonlyArray<ResolversParentTypes['ReportCommentaryRecord']> };
  ReportCommentaryRecord: CommentaryRecordProto;
  ReportCommentarySubRecord: CommentarySubRecordProto;
  Salary: IGetAllSalaryRecordsResult;
  SalaryCharge: IGetChargesByIdsResult;
  SalaryRecordEditInput: SalaryRecordEditInput;
  SalaryRecordInput: SalaryRecordInput;
  SicknessDays: SicknessDays;
  SingleSidedLedgerRecord: Omit<SingleSidedLedgerRecord, 'amount' | 'counterParty'> & { amount: ResolversParentTypes['FinancialAmount'], counterParty?: Maybe<ResolversParentTypes['FinancialEntity']> };
  SortCode: IGetSortCodesByIdsResult;
  String: Scalars['String']['output'];
  Suggestions: Omit<Suggestions, 'tags'> & { tags: ReadonlyArray<ResolversParentTypes['Tag']> };
  SuggestionsInput: SuggestionsInput;
  Tag: IGetAllTagsResult;
  TagInput: TagInput;
  TaxCategory: IGetAllTaxCategoriesResult;
  TaxReport: Omit<TaxReport, 'reference' | 'report'> & { reference: ReadonlyArray<ResolversParentTypes['TaxReportYear']>, report: ResolversParentTypes['TaxReportYear'] };
  TaxReportYear: TaxReportYearProto;
  TimelessDate: Scalars['TimelessDate']['output'];
  TrainingFund: TrainingFund;
  Transaction: ResolversInterfaceTypes<ResolversParentTypes>['Transaction'];
  TransactionSuggestions: Omit<TransactionSuggestions, 'business'> & { business: ResolversParentTypes['FinancialEntity'] };
  URL: Scalars['URL']['output'];
  UUID: Scalars['UUID']['output'];
  UncategorizedTransaction: Omit<UncategorizedTransaction, 'categorizedAmount' | 'transaction'> & { categorizedAmount: ResolversParentTypes['FinancialAmount'], transaction: ResolversParentTypes['Transaction'] };
  Unprocessed: IGetAllDocumentsResult;
  UpdateBusinessInput: UpdateBusinessInput;
  UpdateBusinessResponse: ResolversUnionTypes<ResolversParentTypes>['UpdateBusinessResponse'];
  UpdateBusinessTripAccommodationsExpenseInput: UpdateBusinessTripAccommodationsExpenseInput;
  UpdateBusinessTripCarRentalExpenseInput: UpdateBusinessTripCarRentalExpenseInput;
  UpdateBusinessTripFlightsExpenseInput: UpdateBusinessTripFlightsExpenseInput;
  UpdateBusinessTripInput: UpdateBusinessTripInput;
  UpdateBusinessTripOtherExpenseInput: UpdateBusinessTripOtherExpenseInput;
  UpdateBusinessTripTravelAndSubsistenceExpenseInput: UpdateBusinessTripTravelAndSubsistenceExpenseInput;
  UpdateChargeInput: UpdateChargeInput;
  UpdateChargeResult: ResolversUnionTypes<ResolversParentTypes>['UpdateChargeResult'];
  UpdateChargeSuccessfulResult: Omit<UpdateChargeSuccessfulResult, 'charge'> & { charge: ResolversParentTypes['Charge'] };
  UpdateDepreciationCategoryInput: UpdateDepreciationCategoryInput;
  UpdateDepreciationCategoryResult: ResolversUnionTypes<ResolversParentTypes>['UpdateDepreciationCategoryResult'];
  UpdateDepreciationRecordInput: UpdateDepreciationRecordInput;
  UpdateDepreciationRecordResult: ResolversUnionTypes<ResolversParentTypes>['UpdateDepreciationRecordResult'];
  UpdateDocumentFieldsInput: UpdateDocumentFieldsInput;
  UpdateDocumentResult: ResolversUnionTypes<ResolversParentTypes>['UpdateDocumentResult'];
  UpdateDocumentSuccessfulResult: Omit<UpdateDocumentSuccessfulResult, 'document'> & { document?: Maybe<ResolversParentTypes['Document']> };
  UpdateMiscExpenseInput: UpdateMiscExpenseInput;
  UpdateSalaryRecordResult: ResolversUnionTypes<ResolversParentTypes>['UpdateSalaryRecordResult'];
  UpdateSalaryRecordSuccessfulResult: Omit<UpdateSalaryRecordSuccessfulResult, 'salaryRecord'> & { salaryRecord: ResolversParentTypes['Salary'] };
  UpdateTagFieldsInput: UpdateTagFieldsInput;
  UpdateTaxCategoryInput: UpdateTaxCategoryInput;
  UpdateTaxCategoryResponse: ResolversUnionTypes<ResolversParentTypes>['UpdateTaxCategoryResponse'];
  UpdateTransactionInput: UpdateTransactionInput;
  UpdateTransactionResult: ResolversUnionTypes<ResolversParentTypes>['UpdateTransactionResult'];
  UploadDocumentResult: ResolversUnionTypes<ResolversParentTypes>['UploadDocumentResult'];
  UploadDocumentSuccessfulResult: Omit<UploadDocumentSuccessfulResult, 'document'> & { document?: Maybe<ResolversParentTypes['Document']> };
  VacationDays: VacationDays;
  ValidationData: Omit<ValidationData, 'balance'> & { balance?: Maybe<ResolversParentTypes['FinancialAmount']> };
  VatMock: Scalars['VatMock']['output'];
  VatReportFilter: VatReportFilter;
  VatReportRecord: RawVatReportRecord;
  VatReportResult: Omit<VatReportResult, 'businessTrips' | 'differentMonthDoc' | 'expenses' | 'income' | 'missingInfo'> & { businessTrips: ReadonlyArray<ResolversParentTypes['Charge']>, differentMonthDoc: ReadonlyArray<ResolversParentTypes['Charge']>, expenses: ReadonlyArray<ResolversParentTypes['VatReportRecord']>, income: ReadonlyArray<ResolversParentTypes['VatReportRecord']>, missingInfo: ReadonlyArray<ResolversParentTypes['Charge']> };
  YearOfRelevance: YearOfRelevance;
  YearOfRelevanceInput: YearOfRelevanceInput;
  YearlyLedgerReport: Omit<YearlyLedgerReport, 'financialEntitiesInfo'> & { financialEntitiesInfo: ReadonlyArray<ResolversParentTypes['YearlyLedgerReportFinancialEntityInfo']> };
  YearlyLedgerReportFinancialEntityInfo: Omit<YearlyLedgerReportFinancialEntityInfo, 'closingBalance' | 'entity' | 'openingBalance' | 'records' | 'totalCredit' | 'totalDebit'> & { closingBalance: ResolversParentTypes['FinancialAmount'], entity: ResolversParentTypes['FinancialEntity'], openingBalance: ResolversParentTypes['FinancialAmount'], records: ReadonlyArray<ResolversParentTypes['SingleSidedLedgerRecord']>, totalCredit: ResolversParentTypes['FinancialAmount'], totalDebit: ResolversParentTypes['FinancialAmount'] };
};

export type AuthDirectiveArgs = {
  role: Role;
};

export type AuthDirectiveResolver<Result, Parent, ContextType = GraphQLModules.Context, Args = AuthDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;

export type DeferDirectiveArgs = { };

export type DeferDirectiveResolver<Result, Parent, ContextType = GraphQLModules.Context, Args = DeferDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;

export type StreamDirectiveArgs = { };

export type StreamDirectiveResolver<Result, Parent, ContextType = GraphQLModules.Context, Args = StreamDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;

export type BankDepositChargeResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BankDepositCharge'] = ResolversParentTypes['BankDepositCharge']> = {
  accountantApproval?: Resolver<ResolversTypes['AccountantStatus'], ParentType, ContextType>;
  additionalDocuments?: Resolver<ReadonlyArray<ResolversTypes['Document']>, ParentType, ContextType>;
  conversion?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  counterparty?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  exchangeRates?: Resolver<Maybe<ResolversTypes['ExchangeRates']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  isInvoicePaymentDifferentCurrency?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  ledger?: Resolver<ResolversTypes['Ledger'], ParentType, ContextType>;
  metadata?: Resolver<Maybe<ResolversTypes['ChargeMetadata']>, ParentType, ContextType>;
  minDebitDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minDocumentsDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minEventDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  miscExpenses?: Resolver<ReadonlyArray<ResolversTypes['MiscExpense']>, ParentType, ContextType>;
  missingInfoSuggestions?: Resolver<Maybe<ResolversTypes['ChargeSuggestions']>, ParentType, ContextType>;
  optionalVAT?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  owner?: Resolver<ResolversTypes['Business'], ParentType, ContextType>;
  property?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  salary?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  tags?: Resolver<ReadonlyArray<ResolversTypes['Tag']>, ParentType, ContextType>;
  taxCategory?: Resolver<Maybe<ResolversTypes['TaxCategory']>, ParentType, ContextType>;
  totalAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  transactions?: Resolver<ReadonlyArray<ResolversTypes['Transaction']>, ParentType, ContextType>;
  userDescription?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  validationData?: Resolver<Maybe<ResolversTypes['ValidationData']>, ParentType, ContextType>;
  vat?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  withholdingTax?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  yearsOfRelevance?: Resolver<Maybe<ReadonlyArray<ResolversTypes['YearOfRelevance']>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type BankFinancialAccountResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BankFinancialAccount'] = ResolversParentTypes['BankFinancialAccount']> = {
  accountNumber?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  bankNumber?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  branchNumber?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  charges?: Resolver<ReadonlyArray<ResolversTypes['Charge']>, ParentType, ContextType, Partial<BankFinancialAccountChargesArgs>>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  type?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type BusinessResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['Business'] = ResolversParentTypes['Business']> = {
  __resolveType?: TypeResolveFn<'LtdFinancialEntity' | 'PersonalFinancialEntity', ParentType, ContextType>;
  accounts?: Resolver<ReadonlyArray<ResolversTypes['FinancialAccount']>, ParentType, ContextType>;
  charges?: Resolver<ResolversTypes['PaginatedCharges'], ParentType, ContextType, RequireFields<BusinessChargesArgs, 'limit' | 'page'>>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  sortCode?: Resolver<Maybe<ResolversTypes['SortCode']>, ParentType, ContextType>;
};

export type BusinessTransactionResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BusinessTransaction'] = ResolversParentTypes['BusinessTransaction']> = {
  amount?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  business?: Resolver<ResolversTypes['FinancialEntity'], ParentType, ContextType>;
  chargeId?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  counterAccount?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  details?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  foreignAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  invoiceDate?: Resolver<ResolversTypes['TimelessDate'], ParentType, ContextType>;
  reference?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type BusinessTransactionSumResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BusinessTransactionSum'] = ResolversParentTypes['BusinessTransactionSum']> = {
  business?: Resolver<ResolversTypes['FinancialEntity'], ParentType, ContextType>;
  credit?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  debit?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  foreignCurrenciesSum?: Resolver<ReadonlyArray<ResolversTypes['ForeignCurrencySum']>, ParentType, ContextType>;
  total?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type BusinessTransactionsFromLedgerRecordsResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BusinessTransactionsFromLedgerRecordsResult'] = ResolversParentTypes['BusinessTransactionsFromLedgerRecordsResult']> = {
  __resolveType?: TypeResolveFn<'BusinessTransactionsFromLedgerRecordsSuccessfulResult' | 'CommonError', ParentType, ContextType>;
};

export type BusinessTransactionsFromLedgerRecordsSuccessfulResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BusinessTransactionsFromLedgerRecordsSuccessfulResult'] = ResolversParentTypes['BusinessTransactionsFromLedgerRecordsSuccessfulResult']> = {
  businessTransactions?: Resolver<ReadonlyArray<ResolversTypes['BusinessTransaction']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type BusinessTransactionsSumFromLedgerRecordsResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BusinessTransactionsSumFromLedgerRecordsResult'] = ResolversParentTypes['BusinessTransactionsSumFromLedgerRecordsResult']> = {
  __resolveType?: TypeResolveFn<'BusinessTransactionsSumFromLedgerRecordsSuccessfulResult' | 'CommonError', ParentType, ContextType>;
};

export type BusinessTransactionsSumFromLedgerRecordsSuccessfulResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BusinessTransactionsSumFromLedgerRecordsSuccessfulResult'] = ResolversParentTypes['BusinessTransactionsSumFromLedgerRecordsSuccessfulResult']> = {
  businessTransactionsSum?: Resolver<ReadonlyArray<ResolversTypes['BusinessTransactionSum']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type BusinessTripResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BusinessTrip'] = ResolversParentTypes['BusinessTrip']> = {
  accommodationExpenses?: Resolver<ReadonlyArray<ResolversTypes['BusinessTripAccommodationExpense']>, ParentType, ContextType>;
  accountantApproval?: Resolver<ResolversTypes['AccountantStatus'], ParentType, ContextType>;
  attendees?: Resolver<ReadonlyArray<ResolversTypes['BusinessTripAttendee']>, ParentType, ContextType>;
  carRentalExpenses?: Resolver<ReadonlyArray<ResolversTypes['BusinessTripCarRentalExpense']>, ParentType, ContextType>;
  dates?: Resolver<Maybe<ResolversTypes['DateRange']>, ParentType, ContextType>;
  destination?: Resolver<Maybe<ResolversTypes['Country']>, ParentType, ContextType>;
  flightExpenses?: Resolver<ReadonlyArray<ResolversTypes['BusinessTripFlightExpense']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  otherExpenses?: Resolver<ReadonlyArray<ResolversTypes['BusinessTripOtherExpense']>, ParentType, ContextType>;
  purpose?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  summary?: Resolver<ResolversTypes['BusinessTripSummary'], ParentType, ContextType>;
  travelAndSubsistenceExpenses?: Resolver<ReadonlyArray<ResolversTypes['BusinessTripTravelAndSubsistenceExpense']>, ParentType, ContextType>;
  uncategorizedTransactions?: Resolver<ReadonlyArray<Maybe<ResolversTypes['UncategorizedTransaction']>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type BusinessTripAccommodationExpenseResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BusinessTripAccommodationExpense'] = ResolversParentTypes['BusinessTripAccommodationExpense']> = {
  amount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  attendeesStay?: Resolver<ReadonlyArray<ResolversTypes['BusinessTripAttendeeStay']>, ParentType, ContextType>;
  businessTrip?: Resolver<ResolversTypes['BusinessTrip'], ParentType, ContextType>;
  charges?: Resolver<Maybe<ReadonlyArray<ResolversTypes['Charge']>>, ParentType, ContextType>;
  country?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  date?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  employee?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  nightsCount?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  payedByEmployee?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  transactions?: Resolver<Maybe<ReadonlyArray<ResolversTypes['Transaction']>>, ParentType, ContextType>;
  valueDate?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type BusinessTripAttendeeResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BusinessTripAttendee'] = ResolversParentTypes['BusinessTripAttendee']> = {
  accommodations?: Resolver<ReadonlyArray<ResolversTypes['BusinessTripAccommodationExpense']>, ParentType, ContextType>;
  arrivalDate?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  business?: Resolver<Maybe<ResolversTypes['Business']>, ParentType, ContextType>;
  departureDate?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  flights?: Resolver<ReadonlyArray<ResolversTypes['BusinessTripFlightExpense']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type BusinessTripAttendeeStayResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BusinessTripAttendeeStay'] = ResolversParentTypes['BusinessTripAttendeeStay']> = {
  attendee?: Resolver<ResolversTypes['BusinessTripAttendee'], ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  nightsCount?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type BusinessTripCarRentalExpenseResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BusinessTripCarRentalExpense'] = ResolversParentTypes['BusinessTripCarRentalExpense']> = {
  amount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  businessTrip?: Resolver<ResolversTypes['BusinessTrip'], ParentType, ContextType>;
  charges?: Resolver<Maybe<ReadonlyArray<ResolversTypes['Charge']>>, ParentType, ContextType>;
  date?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  days?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  employee?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  isFuelExpense?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
  payedByEmployee?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  transactions?: Resolver<Maybe<ReadonlyArray<ResolversTypes['Transaction']>>, ParentType, ContextType>;
  valueDate?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type BusinessTripChargeResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BusinessTripCharge'] = ResolversParentTypes['BusinessTripCharge']> = {
  accountantApproval?: Resolver<ResolversTypes['AccountantStatus'], ParentType, ContextType>;
  additionalDocuments?: Resolver<ReadonlyArray<ResolversTypes['Document']>, ParentType, ContextType>;
  businessTrip?: Resolver<Maybe<ResolversTypes['BusinessTrip']>, ParentType, ContextType>;
  conversion?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  counterparty?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  exchangeRates?: Resolver<Maybe<ResolversTypes['ExchangeRates']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  isInvoicePaymentDifferentCurrency?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  ledger?: Resolver<ResolversTypes['Ledger'], ParentType, ContextType>;
  metadata?: Resolver<Maybe<ResolversTypes['ChargeMetadata']>, ParentType, ContextType>;
  minDebitDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minDocumentsDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minEventDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  miscExpenses?: Resolver<ReadonlyArray<ResolversTypes['MiscExpense']>, ParentType, ContextType>;
  missingInfoSuggestions?: Resolver<Maybe<ResolversTypes['ChargeSuggestions']>, ParentType, ContextType>;
  optionalVAT?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  owner?: Resolver<ResolversTypes['Business'], ParentType, ContextType>;
  property?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  salary?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  tags?: Resolver<ReadonlyArray<ResolversTypes['Tag']>, ParentType, ContextType>;
  taxCategory?: Resolver<Maybe<ResolversTypes['TaxCategory']>, ParentType, ContextType>;
  totalAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  transactions?: Resolver<ReadonlyArray<ResolversTypes['Transaction']>, ParentType, ContextType>;
  userDescription?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  validationData?: Resolver<Maybe<ResolversTypes['ValidationData']>, ParentType, ContextType>;
  vat?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  withholdingTax?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  yearsOfRelevance?: Resolver<Maybe<ReadonlyArray<ResolversTypes['YearOfRelevance']>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type BusinessTripExpenseResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BusinessTripExpense'] = ResolversParentTypes['BusinessTripExpense']> = {
  __resolveType?: TypeResolveFn<'BusinessTripAccommodationExpense' | 'BusinessTripCarRentalExpense' | 'BusinessTripFlightExpense' | 'BusinessTripOtherExpense' | 'BusinessTripTravelAndSubsistenceExpense', ParentType, ContextType>;
  amount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  businessTrip?: Resolver<ResolversTypes['BusinessTrip'], ParentType, ContextType>;
  charges?: Resolver<Maybe<ReadonlyArray<ResolversTypes['Charge']>>, ParentType, ContextType>;
  date?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  employee?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  payedByEmployee?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  transactions?: Resolver<Maybe<ReadonlyArray<ResolversTypes['Transaction']>>, ParentType, ContextType>;
  valueDate?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
};

export type BusinessTripFlightExpenseResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BusinessTripFlightExpense'] = ResolversParentTypes['BusinessTripFlightExpense']> = {
  amount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  attendees?: Resolver<ReadonlyArray<ResolversTypes['BusinessTripAttendee']>, ParentType, ContextType>;
  businessTrip?: Resolver<ResolversTypes['BusinessTrip'], ParentType, ContextType>;
  charges?: Resolver<Maybe<ReadonlyArray<ResolversTypes['Charge']>>, ParentType, ContextType>;
  class?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  date?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  employee?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  path?: Resolver<Maybe<ReadonlyArray<ResolversTypes['String']>>, ParentType, ContextType>;
  payedByEmployee?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  transactions?: Resolver<Maybe<ReadonlyArray<ResolversTypes['Transaction']>>, ParentType, ContextType>;
  valueDate?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type BusinessTripOtherExpenseResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BusinessTripOtherExpense'] = ResolversParentTypes['BusinessTripOtherExpense']> = {
  amount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  businessTrip?: Resolver<ResolversTypes['BusinessTrip'], ParentType, ContextType>;
  charges?: Resolver<Maybe<ReadonlyArray<ResolversTypes['Charge']>>, ParentType, ContextType>;
  date?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  deductibleExpense?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  description?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  employee?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  payedByEmployee?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  transactions?: Resolver<Maybe<ReadonlyArray<ResolversTypes['Transaction']>>, ParentType, ContextType>;
  valueDate?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type BusinessTripSummaryResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BusinessTripSummary'] = ResolversParentTypes['BusinessTripSummary']> = {
  errors?: Resolver<Maybe<ReadonlyArray<ResolversTypes['String']>>, ParentType, ContextType>;
  excessExpenditure?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  excessTax?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  rows?: Resolver<ReadonlyArray<ResolversTypes['BusinessTripSummaryRow']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type BusinessTripSummaryRowResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BusinessTripSummaryRow'] = ResolversParentTypes['BusinessTripSummaryRow']> = {
  excessExpenditure?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  maxTaxableForeignCurrency?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  maxTaxableLocalCurrency?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  taxableForeignCurrency?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  taxableLocalCurrency?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  totalForeignCurrency?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  totalLocalCurrency?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  type?: Resolver<ResolversTypes['BusinessTripSummaryCategories'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type BusinessTripTravelAndSubsistenceExpenseResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['BusinessTripTravelAndSubsistenceExpense'] = ResolversParentTypes['BusinessTripTravelAndSubsistenceExpense']> = {
  amount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  businessTrip?: Resolver<ResolversTypes['BusinessTrip'], ParentType, ContextType>;
  charges?: Resolver<Maybe<ReadonlyArray<ResolversTypes['Charge']>>, ParentType, ContextType>;
  date?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  employee?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  expenseType?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  payedByEmployee?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  transactions?: Resolver<Maybe<ReadonlyArray<ResolversTypes['Transaction']>>, ParentType, ContextType>;
  valueDate?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type CardFinancialAccountResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['CardFinancialAccount'] = ResolversParentTypes['CardFinancialAccount']> = {
  charges?: Resolver<ReadonlyArray<ResolversTypes['Charge']>, ParentType, ContextType, Partial<CardFinancialAccountChargesArgs>>;
  fourDigits?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  number?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  type?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ChargeResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['Charge'] = ResolversParentTypes['Charge']> = {
  __resolveType?: TypeResolveFn<'BankDepositCharge' | 'BusinessTripCharge' | 'CommonCharge' | 'ConversionCharge' | 'CreditcardBankCharge' | 'DividendCharge' | 'FinancialCharge' | 'InternalTransferCharge' | 'MonthlyVatCharge' | 'SalaryCharge', ParentType, ContextType>;
  accountantApproval?: Resolver<ResolversTypes['AccountantStatus'], ParentType, ContextType>;
  additionalDocuments?: Resolver<ReadonlyArray<ResolversTypes['Document']>, ParentType, ContextType>;
  conversion?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  counterparty?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  exchangeRates?: Resolver<Maybe<ResolversTypes['ExchangeRates']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  isInvoicePaymentDifferentCurrency?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  ledger?: Resolver<ResolversTypes['Ledger'], ParentType, ContextType>;
  metadata?: Resolver<Maybe<ResolversTypes['ChargeMetadata']>, ParentType, ContextType>;
  minDebitDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minDocumentsDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minEventDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  miscExpenses?: Resolver<ReadonlyArray<ResolversTypes['MiscExpense']>, ParentType, ContextType>;
  missingInfoSuggestions?: Resolver<Maybe<ResolversTypes['ChargeSuggestions']>, ParentType, ContextType>;
  optionalVAT?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  owner?: Resolver<ResolversTypes['Business'], ParentType, ContextType>;
  property?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  salary?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  tags?: Resolver<ReadonlyArray<ResolversTypes['Tag']>, ParentType, ContextType>;
  taxCategory?: Resolver<Maybe<ResolversTypes['TaxCategory']>, ParentType, ContextType>;
  totalAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  transactions?: Resolver<ReadonlyArray<ResolversTypes['Transaction']>, ParentType, ContextType>;
  userDescription?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  validationData?: Resolver<Maybe<ResolversTypes['ValidationData']>, ParentType, ContextType>;
  vat?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  withholdingTax?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  yearsOfRelevance?: Resolver<Maybe<ReadonlyArray<ResolversTypes['YearOfRelevance']>>, 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>;
  invalidDocuments?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
  invalidLedger?: Resolver<ResolversTypes['LedgerValidationStatus'], ParentType, ContextType>;
  invalidTransactions?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
  invoicesCount?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  isSalary?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
  ledgerCount?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  miscExpensesCount?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  optionalBusinesses?: Resolver<ReadonlyArray<ResolversTypes['String']>, ParentType, ContextType>;
  receiptsCount?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  transactionsCount?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  updatedAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ChargeSortByFieldResolvers = EnumResolverSignature<{ ABS_AMOUNT?: any, AMOUNT?: any, DATE?: any }, ResolversTypes['ChargeSortByField']>;

export type ChargeSuggestionsResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['ChargeSuggestions'] = ResolversParentTypes['ChargeSuggestions']> = {
  description?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  tags?: Resolver<ReadonlyArray<ResolversTypes['Tag']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ChargesWithLedgerChangesResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['ChargesWithLedgerChangesResult'] = ResolversParentTypes['ChargesWithLedgerChangesResult']> = {
  charge?: Resolver<Maybe<ResolversTypes['Charge']>, ParentType, ContextType>;
  progress?: Resolver<ResolversTypes['Float'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type CommonChargeResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['CommonCharge'] = ResolversParentTypes['CommonCharge']> = {
  accountantApproval?: Resolver<ResolversTypes['AccountantStatus'], ParentType, ContextType>;
  additionalDocuments?: Resolver<ReadonlyArray<ResolversTypes['Document']>, ParentType, ContextType>;
  conversion?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  counterparty?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  depreciationRecords?: Resolver<ReadonlyArray<ResolversTypes['DepreciationRecord']>, ParentType, ContextType>;
  exchangeRates?: Resolver<Maybe<ResolversTypes['ExchangeRates']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  isInvoicePaymentDifferentCurrency?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  ledger?: Resolver<ResolversTypes['Ledger'], ParentType, ContextType>;
  metadata?: Resolver<Maybe<ResolversTypes['ChargeMetadata']>, ParentType, ContextType>;
  minDebitDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minDocumentsDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minEventDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  miscExpenses?: Resolver<ReadonlyArray<ResolversTypes['MiscExpense']>, ParentType, ContextType>;
  missingInfoSuggestions?: Resolver<Maybe<ResolversTypes['ChargeSuggestions']>, ParentType, ContextType>;
  optionalVAT?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  owner?: Resolver<ResolversTypes['Business'], ParentType, ContextType>;
  property?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  salary?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  tags?: Resolver<ReadonlyArray<ResolversTypes['Tag']>, ParentType, ContextType>;
  taxCategory?: Resolver<Maybe<ResolversTypes['TaxCategory']>, ParentType, ContextType>;
  totalAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  transactions?: Resolver<ReadonlyArray<ResolversTypes['Transaction']>, ParentType, ContextType>;
  userDescription?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  validationData?: Resolver<Maybe<ResolversTypes['ValidationData']>, ParentType, ContextType>;
  vat?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  withholdingTax?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  yearsOfRelevance?: Resolver<Maybe<ReadonlyArray<ResolversTypes['YearOfRelevance']>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type CommonErrorResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['CommonError'] = ResolversParentTypes['CommonError']> = {
  message?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type CommonTransactionResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['CommonTransaction'] = ResolversParentTypes['CommonTransaction']> = {
  account?: Resolver<ResolversTypes['FinancialAccount'], ParentType, ContextType>;
  amount?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  balance?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  chargeId?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  counterparty?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  createdAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
  cryptoExchangeRate?: Resolver<Maybe<ResolversTypes['ConversionRate']>, ParentType, ContextType>;
  debitExchangeRates?: Resolver<Maybe<ResolversTypes['ExchangeRates']>, ParentType, ContextType>;
  direction?: Resolver<ResolversTypes['TransactionDirection'], ParentType, ContextType>;
  effectiveDate?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  eventDate?: Resolver<ResolversTypes['TimelessDate'], ParentType, ContextType>;
  eventExchangeRates?: Resolver<Maybe<ResolversTypes['ExchangeRates']>, ParentType, ContextType>;
  exactEffectiveDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  isFee?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  missingInfoSuggestions?: Resolver<Maybe<ResolversTypes['TransactionSuggestions']>, ParentType, ContextType>;
  referenceId?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  referenceKey?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  sourceDescription?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  sourceEffectiveDate?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  updatedAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ConversionChargeResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['ConversionCharge'] = ResolversParentTypes['ConversionCharge']> = {
  accountantApproval?: Resolver<ResolversTypes['AccountantStatus'], ParentType, ContextType>;
  additionalDocuments?: Resolver<ReadonlyArray<ResolversTypes['Document']>, ParentType, ContextType>;
  conversion?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  counterparty?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  eventRate?: Resolver<Maybe<ResolversTypes['ConversionRate']>, ParentType, ContextType>;
  exchangeRates?: Resolver<Maybe<ResolversTypes['ExchangeRates']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  isInvoicePaymentDifferentCurrency?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  ledger?: Resolver<ResolversTypes['Ledger'], ParentType, ContextType>;
  metadata?: Resolver<Maybe<ResolversTypes['ChargeMetadata']>, ParentType, ContextType>;
  minDebitDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minDocumentsDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minEventDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  miscExpenses?: Resolver<ReadonlyArray<ResolversTypes['MiscExpense']>, ParentType, ContextType>;
  missingInfoSuggestions?: Resolver<Maybe<ResolversTypes['ChargeSuggestions']>, ParentType, ContextType>;
  officialRate?: Resolver<Maybe<ResolversTypes['ConversionRate']>, ParentType, ContextType>;
  optionalVAT?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  owner?: Resolver<ResolversTypes['Business'], ParentType, ContextType>;
  property?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  salary?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  tags?: Resolver<ReadonlyArray<ResolversTypes['Tag']>, ParentType, ContextType>;
  taxCategory?: Resolver<Maybe<ResolversTypes['TaxCategory']>, ParentType, ContextType>;
  totalAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  transactions?: Resolver<ReadonlyArray<ResolversTypes['Transaction']>, ParentType, ContextType>;
  userDescription?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  validationData?: Resolver<Maybe<ResolversTypes['ValidationData']>, ParentType, ContextType>;
  vat?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  withholdingTax?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  yearsOfRelevance?: Resolver<Maybe<ReadonlyArray<ResolversTypes['YearOfRelevance']>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ConversionRateResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['ConversionRate'] = ResolversParentTypes['ConversionRate']> = {
  from?: Resolver<ResolversTypes['Currency'], ParentType, ContextType>;
  rate?: Resolver<ResolversTypes['Float'], ParentType, ContextType>;
  to?: Resolver<ResolversTypes['Currency'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ConversionTransactionResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['ConversionTransaction'] = ResolversParentTypes['ConversionTransaction']> = {
  account?: Resolver<ResolversTypes['FinancialAccount'], ParentType, ContextType>;
  amount?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  balance?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  bankRate?: Resolver<ResolversTypes['Rate'], ParentType, ContextType>;
  chargeId?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  counterparty?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  createdAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
  cryptoExchangeRate?: Resolver<Maybe<ResolversTypes['ConversionRate']>, ParentType, ContextType>;
  debitExchangeRates?: Resolver<Maybe<ResolversTypes['ExchangeRates']>, ParentType, ContextType>;
  direction?: Resolver<ResolversTypes['TransactionDirection'], ParentType, ContextType>;
  effectiveDate?: Resolver<ResolversTypes['TimelessDate'], ParentType, ContextType>;
  eventDate?: Resolver<ResolversTypes['TimelessDate'], ParentType, ContextType>;
  eventExchangeRates?: Resolver<Maybe<ResolversTypes['ExchangeRates']>, ParentType, ContextType>;
  exactEffectiveDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  isFee?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  missingInfoSuggestions?: Resolver<Maybe<ResolversTypes['TransactionSuggestions']>, ParentType, ContextType>;
  officialRateToLocal?: Resolver<Maybe<ResolversTypes['Rate']>, ParentType, ContextType>;
  referenceId?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  referenceKey?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  sourceDescription?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  sourceEffectiveDate?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  type?: Resolver<ResolversTypes['ConversionTransactionType'], ParentType, ContextType>;
  updatedAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type CorporateTaxResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['CorporateTax'] = ResolversParentTypes['CorporateTax']> = {
  corporateId?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  date?: Resolver<ResolversTypes['TimelessDate'], ParentType, ContextType>;
  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  taxRate?: Resolver<ResolversTypes['Float'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type CorporateTaxRuleResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['CorporateTaxRule'] = ResolversParentTypes['CorporateTaxRule']> = {
  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  isCompliant?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
  percentage?: Resolver<ResolversTypes['CorporateTaxRulePercentage'], ParentType, ContextType>;
  rule?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type CorporateTaxRulePercentageResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['CorporateTaxRulePercentage'] = ResolversParentTypes['CorporateTaxRulePercentage']> = {
  formatted?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  value?: Resolver<ResolversTypes['Float'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type CorporateTaxRulingComplianceReportResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['CorporateTaxRulingComplianceReport'] = ResolversParentTypes['CorporateTaxRulingComplianceReport']> = {
  businessTripRndExpenses?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  differences?: Resolver<ResolversTypes['CorporateTaxRulingComplianceReportDifferences'], ParentType, ContextType>;
  foreignDevelopmentExpenses?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  foreignDevelopmentRelativeToRnd?: Resolver<ResolversTypes['CorporateTaxRule'], ParentType, ContextType>;
  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  localDevelopmentExpenses?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  localDevelopmentRelativeToRnd?: Resolver<ResolversTypes['CorporateTaxRule'], ParentType, ContextType>;
  researchAndDevelopmentExpenses?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  rndRelativeToIncome?: Resolver<ResolversTypes['CorporateTaxRule'], ParentType, ContextType>;
  totalIncome?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  year?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type CorporateTaxRulingComplianceReportDifferencesResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['CorporateTaxRulingComplianceReportDifferences'] = ResolversParentTypes['CorporateTaxRulingComplianceReportDifferences']> = {
  businessTripRndExpenses?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  foreignDevelopmentExpenses?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  foreignDevelopmentRelativeToRnd?: Resolver<Maybe<ResolversTypes['CorporateTaxRule']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  localDevelopmentExpenses?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  localDevelopmentRelativeToRnd?: Resolver<Maybe<ResolversTypes['CorporateTaxRule']>, ParentType, ContextType>;
  researchAndDevelopmentExpenses?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  rndRelativeToIncome?: Resolver<Maybe<ResolversTypes['CorporateTaxRule']>, ParentType, ContextType>;
  totalIncome?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type CountryResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['Country'] = ResolversParentTypes['Country']> = {
  code?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type CreditInvoiceResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['CreditInvoice'] = ResolversParentTypes['CreditInvoice']> = {
  amount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  charge?: Resolver<Maybe<ResolversTypes['Charge']>, ParentType, ContextType>;
  creditor?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  date?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  debtor?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  documentType?: Resolver<Maybe<ResolversTypes['DocumentType']>, ParentType, ContextType>;
  file?: Resolver<Maybe<ResolversTypes['URL']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  image?: Resolver<Maybe<ResolversTypes['URL']>, ParentType, ContextType>;
  isReviewed?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  missingInfoSuggestions?: Resolver<Maybe<ResolversTypes['DocumentSuggestions']>, ParentType, ContextType>;
  noVatAmount?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  serialNumber?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  vat?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  vatReportDateOverride?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type CreditcardBankChargeResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['CreditcardBankCharge'] = ResolversParentTypes['CreditcardBankCharge']> = {
  accountantApproval?: Resolver<ResolversTypes['AccountantStatus'], ParentType, ContextType>;
  additionalDocuments?: Resolver<ReadonlyArray<ResolversTypes['Document']>, ParentType, ContextType>;
  conversion?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  counterparty?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  creditCardTransactions?: Resolver<ReadonlyArray<ResolversTypes['Transaction']>, ParentType, ContextType>;
  exchangeRates?: Resolver<Maybe<ResolversTypes['ExchangeRates']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  isInvoicePaymentDifferentCurrency?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  ledger?: Resolver<ResolversTypes['Ledger'], ParentType, ContextType>;
  metadata?: Resolver<Maybe<ResolversTypes['ChargeMetadata']>, ParentType, ContextType>;
  minDebitDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minDocumentsDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minEventDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  miscExpenses?: Resolver<ReadonlyArray<ResolversTypes['MiscExpense']>, ParentType, ContextType>;
  missingInfoSuggestions?: Resolver<Maybe<ResolversTypes['ChargeSuggestions']>, ParentType, ContextType>;
  optionalVAT?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  owner?: Resolver<ResolversTypes['Business'], ParentType, ContextType>;
  property?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  salary?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  tags?: Resolver<ReadonlyArray<ResolversTypes['Tag']>, ParentType, ContextType>;
  taxCategory?: Resolver<Maybe<ResolversTypes['TaxCategory']>, ParentType, ContextType>;
  totalAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  transactions?: Resolver<ReadonlyArray<ResolversTypes['Transaction']>, ParentType, ContextType>;
  userDescription?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  validCreditCardAmount?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
  validationData?: Resolver<Maybe<ResolversTypes['ValidationData']>, ParentType, ContextType>;
  vat?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  withholdingTax?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  yearsOfRelevance?: Resolver<Maybe<ReadonlyArray<ResolversTypes['YearOfRelevance']>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type CryptoWalletFinancialAccountResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['CryptoWalletFinancialAccount'] = ResolversParentTypes['CryptoWalletFinancialAccount']> = {
  charges?: Resolver<ReadonlyArray<ResolversTypes['Charge']>, ParentType, ContextType, Partial<CryptoWalletFinancialAccountChargesArgs>>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  number?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  type?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type CurrencyResolvers = EnumResolverSignature<{ CAD?: any, ETH?: any, EUR?: any, GBP?: any, GRT?: any, ILS?: any, USD?: any, USDC?: any }, ResolversTypes['Currency']>;

export type DateRangeResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['DateRange'] = ResolversParentTypes['DateRange']> = {
  end?: Resolver<ResolversTypes['TimelessDate'], ParentType, ContextType>;
  start?: Resolver<ResolversTypes['TimelessDate'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export interface DateTimeScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['DateTime'], any> {
  name: 'DateTime';
}

export type DepreciationCategoryResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['DepreciationCategory'] = ResolversParentTypes['DepreciationCategory']> = {
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  percentage?: Resolver<ResolversTypes['Float'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type DepreciationRecordResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['DepreciationRecord'] = ResolversParentTypes['DepreciationRecord']> = {
  activationDate?: Resolver<ResolversTypes['TimelessDate'], ParentType, ContextType>;
  amount?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  category?: Resolver<ResolversTypes['DepreciationCategory'], ParentType, ContextType>;
  charge?: Resolver<ResolversTypes['Charge'], ParentType, ContextType>;
  chargeId?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  type?: Resolver<Maybe<ResolversTypes['DepreciationType']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type DividendChargeResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['DividendCharge'] = ResolversParentTypes['DividendCharge']> = {
  accountantApproval?: Resolver<ResolversTypes['AccountantStatus'], ParentType, ContextType>;
  additionalDocuments?: Resolver<ReadonlyArray<ResolversTypes['Document']>, ParentType, ContextType>;
  conversion?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  counterparty?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  exchangeRates?: Resolver<Maybe<ResolversTypes['ExchangeRates']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  isInvoicePaymentDifferentCurrency?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  ledger?: Resolver<ResolversTypes['Ledger'], ParentType, ContextType>;
  metadata?: Resolver<Maybe<ResolversTypes['ChargeMetadata']>, ParentType, ContextType>;
  minDebitDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minDocumentsDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minEventDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  miscExpenses?: Resolver<ReadonlyArray<ResolversTypes['MiscExpense']>, ParentType, ContextType>;
  missingInfoSuggestions?: Resolver<Maybe<ResolversTypes['ChargeSuggestions']>, ParentType, ContextType>;
  optionalVAT?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  owner?: Resolver<ResolversTypes['Business'], ParentType, ContextType>;
  property?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  salary?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  tags?: Resolver<ReadonlyArray<ResolversTypes['Tag']>, ParentType, ContextType>;
  taxCategory?: Resolver<Maybe<ResolversTypes['TaxCategory']>, ParentType, ContextType>;
  totalAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  transactions?: Resolver<ReadonlyArray<ResolversTypes['Transaction']>, ParentType, ContextType>;
  userDescription?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  validationData?: Resolver<Maybe<ResolversTypes['ValidationData']>, ParentType, ContextType>;
  vat?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  withholdingTax?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  yearsOfRelevance?: Resolver<Maybe<ReadonlyArray<ResolversTypes['YearOfRelevance']>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export interface DividendMockScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['DividendMock'], any> {
  name: 'DividendMock';
}

export type DocumentResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['Document'] = ResolversParentTypes['Document']> = {
  __resolveType?: TypeResolveFn<'CreditInvoice' | 'Invoice' | 'InvoiceReceipt' | 'OtherDocument' | 'Proforma' | 'Receipt' | 'Unprocessed', ParentType, ContextType>;
  charge?: Resolver<Maybe<ResolversTypes['Charge']>, ParentType, ContextType>;
  documentType?: Resolver<Maybe<ResolversTypes['DocumentType']>, ParentType, ContextType>;
  file?: Resolver<Maybe<ResolversTypes['URL']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  image?: Resolver<Maybe<ResolversTypes['URL']>, ParentType, ContextType>;
  isReviewed?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
};

export type DocumentSuggestionsResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['DocumentSuggestions'] = ResolversParentTypes['DocumentSuggestions']> = {
  amount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  counterparty?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  isIncome?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  owner?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type DocumentTypeResolvers = EnumResolverSignature<{ CREDIT_INVOICE?: any, INVOICE?: any, INVOICE_RECEIPT?: any, OTHER?: any, PROFORMA?: any, RECEIPT?: any, UNPROCESSED?: any }, ResolversTypes['DocumentType']>;

export type DynamicReportInfoResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['DynamicReportInfo'] = ResolversParentTypes['DynamicReportInfo']> = {
  created?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  template?: Resolver<ReadonlyArray<ResolversTypes['DynamicReportNode']>, ParentType, ContextType>;
  updated?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type DynamicReportNodeResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['DynamicReportNode'] = ResolversParentTypes['DynamicReportNode']> = {
  data?: Resolver<ResolversTypes['DynamicReportNodeData'], ParentType, ContextType>;
  droppable?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  parent?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  text?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type DynamicReportNodeDataResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['DynamicReportNodeData'] = ResolversParentTypes['DynamicReportNodeData']> = {
  descendantFinancialEntities?: Resolver<Maybe<ReadonlyArray<ResolversTypes['UUID']>>, ParentType, ContextType>;
  descendantSortCodes?: Resolver<Maybe<ReadonlyArray<ResolversTypes['Int']>>, ParentType, ContextType>;
  hebrewText?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  isOpen?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
  mergedSortCodes?: Resolver<Maybe<ReadonlyArray<ResolversTypes['Int']>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type EmployeeResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['Employee'] = ResolversParentTypes['Employee']> = {
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ErrorResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['Error'] = ResolversParentTypes['Error']> = {
  __resolveType?: TypeResolveFn<'CommonError', ParentType, ContextType>;
  message?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
};

export type ExchangeRatesResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['ExchangeRates'] = ResolversParentTypes['ExchangeRates']> = {
  cad?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  date?: Resolver<ResolversTypes['TimelessDate'], ParentType, ContextType>;
  eur?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  gbp?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  usd?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export interface FileScalarScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['FileScalar'], any> {
  name: 'FileScalar';
}

export type FinancialAccountResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['FinancialAccount'] = ResolversParentTypes['FinancialAccount']> = {
  __resolveType?: TypeResolveFn<'BankFinancialAccount' | 'CardFinancialAccount' | 'CryptoWalletFinancialAccount', ParentType, ContextType>;
  charges?: Resolver<ReadonlyArray<ResolversTypes['Charge']>, ParentType, ContextType, Partial<FinancialAccountChargesArgs>>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  type?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
};

export type FinancialAmountResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['FinancialAmount'] = ResolversParentTypes['FinancialAmount']> = {
  currency?: Resolver<ResolversTypes['Currency'], ParentType, ContextType>;
  formatted?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  raw?: Resolver<ResolversTypes['Float'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type FinancialChargeResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['FinancialCharge'] = ResolversParentTypes['FinancialCharge']> = {
  accountantApproval?: Resolver<ResolversTypes['AccountantStatus'], ParentType, ContextType>;
  additionalDocuments?: Resolver<ReadonlyArray<ResolversTypes['Document']>, ParentType, ContextType>;
  conversion?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  counterparty?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  exchangeRates?: Resolver<Maybe<ResolversTypes['ExchangeRates']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  isInvoicePaymentDifferentCurrency?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  ledger?: Resolver<ResolversTypes['Ledger'], ParentType, ContextType>;
  metadata?: Resolver<Maybe<ResolversTypes['ChargeMetadata']>, ParentType, ContextType>;
  minDebitDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minDocumentsDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minEventDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  miscExpenses?: Resolver<ReadonlyArray<ResolversTypes['MiscExpense']>, ParentType, ContextType>;
  missingInfoSuggestions?: Resolver<Maybe<ResolversTypes['ChargeSuggestions']>, ParentType, ContextType>;
  optionalVAT?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  owner?: Resolver<ResolversTypes['Business'], ParentType, ContextType>;
  property?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  salary?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  tags?: Resolver<ReadonlyArray<ResolversTypes['Tag']>, ParentType, ContextType>;
  taxCategory?: Resolver<Maybe<ResolversTypes['TaxCategory']>, ParentType, ContextType>;
  totalAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  transactions?: Resolver<ReadonlyArray<ResolversTypes['Transaction']>, ParentType, ContextType>;
  userDescription?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  validationData?: Resolver<Maybe<ResolversTypes['ValidationData']>, ParentType, ContextType>;
  vat?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  withholdingTax?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  yearsOfRelevance?: Resolver<Maybe<ReadonlyArray<ResolversTypes['YearOfRelevance']>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type FinancialDocumentResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['FinancialDocument'] = ResolversParentTypes['FinancialDocument']> = {
  __resolveType?: TypeResolveFn<'CreditInvoice' | 'Invoice' | 'InvoiceReceipt' | 'Proforma' | 'Receipt', ParentType, ContextType>;
  amount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  charge?: Resolver<Maybe<ResolversTypes['Charge']>, ParentType, ContextType>;
  creditor?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  date?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  debtor?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  documentType?: Resolver<Maybe<ResolversTypes['DocumentType']>, ParentType, ContextType>;
  file?: Resolver<Maybe<ResolversTypes['URL']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  image?: Resolver<Maybe<ResolversTypes['URL']>, ParentType, ContextType>;
  isReviewed?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  missingInfoSuggestions?: Resolver<Maybe<ResolversTypes['DocumentSuggestions']>, ParentType, ContextType>;
  noVatAmount?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  serialNumber?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  vat?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  vatReportDateOverride?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
};

export type FinancialEntityResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['FinancialEntity'] = ResolversParentTypes['FinancialEntity']> = {
  __resolveType?: TypeResolveFn<'LtdFinancialEntity' | 'PersonalFinancialEntity' | 'TaxCategory', ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  sortCode?: Resolver<Maybe<ResolversTypes['SortCode']>, ParentType, ContextType>;
};

export type FinancialIntAmountResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['FinancialIntAmount'] = ResolversParentTypes['FinancialIntAmount']> = {
  currency?: Resolver<ResolversTypes['Currency'], ParentType, ContextType>;
  formatted?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  raw?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type FlagForeignFeeTransactionsResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['FlagForeignFeeTransactionsResult'] = ResolversParentTypes['FlagForeignFeeTransactionsResult']> = {
  errors?: Resolver<Maybe<ReadonlyArray<ResolversTypes['String']>>, ParentType, ContextType>;
  success?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
  transactions?: Resolver<Maybe<ReadonlyArray<ResolversTypes['Transaction']>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ForeignCurrencySumResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['ForeignCurrencySum'] = ResolversParentTypes['ForeignCurrencySum']> = {
  credit?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  currency?: Resolver<ResolversTypes['Currency'], ParentType, ContextType>;
  debit?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  total?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type FundResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['Fund'] = ResolversParentTypes['Fund']> = {
  __resolveType?: TypeResolveFn<'PensionFund' | 'TrainingFund', ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
};

export type GenerateMonthlyClientDocumentsResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['GenerateMonthlyClientDocumentsResult'] = ResolversParentTypes['GenerateMonthlyClientDocumentsResult']> = {
  errors?: Resolver<Maybe<ReadonlyArray<ResolversTypes['String']>>, ParentType, ContextType>;
  success?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type GeneratedLedgerRecordsResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['GeneratedLedgerRecords'] = ResolversParentTypes['GeneratedLedgerRecords']> = {
  __resolveType?: TypeResolveFn<'CommonError' | 'Ledger', ParentType, ContextType>;
};

export type IncomeExpenseChartResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['IncomeExpenseChart'] = ResolversParentTypes['IncomeExpenseChart']> = {
  currency?: Resolver<ResolversTypes['Currency'], ParentType, ContextType>;
  fromDate?: Resolver<ResolversTypes['TimelessDate'], ParentType, ContextType>;
  monthlyData?: Resolver<ReadonlyArray<ResolversTypes['IncomeExpenseChartMonthData']>, ParentType, ContextType>;
  toDate?: Resolver<ResolversTypes['TimelessDate'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IncomeExpenseChartMonthDataResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['IncomeExpenseChartMonthData'] = ResolversParentTypes['IncomeExpenseChartMonthData']> = {
  balance?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  date?: Resolver<ResolversTypes['TimelessDate'], ParentType, ContextType>;
  expense?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  income?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type InsertDepreciationCategoryResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['InsertDepreciationCategoryResult'] = ResolversParentTypes['InsertDepreciationCategoryResult']> = {
  __resolveType?: TypeResolveFn<'CommonError' | 'DepreciationCategory', ParentType, ContextType>;
};

export type InsertDepreciationRecordResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['InsertDepreciationRecordResult'] = ResolversParentTypes['InsertDepreciationRecordResult']> = {
  __resolveType?: TypeResolveFn<'CommonError' | 'DepreciationRecord', ParentType, ContextType>;
};

export type InsertDocumentResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['InsertDocumentResult'] = ResolversParentTypes['InsertDocumentResult']> = {
  __resolveType?: TypeResolveFn<'CommonError' | 'InsertDocumentSuccessfulResult', ParentType, ContextType>;
};

export type InsertDocumentSuccessfulResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['InsertDocumentSuccessfulResult'] = ResolversParentTypes['InsertDocumentSuccessfulResult']> = {
  document?: Resolver<Maybe<ResolversTypes['Document']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type InsertSalaryRecordsResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['InsertSalaryRecordsResult'] = ResolversParentTypes['InsertSalaryRecordsResult']> = {
  __resolveType?: TypeResolveFn<'CommonError' | 'InsertSalaryRecordsSuccessfulResult', ParentType, ContextType>;
};

export type InsertSalaryRecordsSuccessfulResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['InsertSalaryRecordsSuccessfulResult'] = ResolversParentTypes['InsertSalaryRecordsSuccessfulResult']> = {
  salaryRecords?: Resolver<ReadonlyArray<ResolversTypes['Salary']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type InternalTransferChargeResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['InternalTransferCharge'] = ResolversParentTypes['InternalTransferCharge']> = {
  accountantApproval?: Resolver<ResolversTypes['AccountantStatus'], ParentType, ContextType>;
  additionalDocuments?: Resolver<ReadonlyArray<ResolversTypes['Document']>, ParentType, ContextType>;
  conversion?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  counterparty?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  exchangeRates?: Resolver<Maybe<ResolversTypes['ExchangeRates']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  isInvoicePaymentDifferentCurrency?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  ledger?: Resolver<ResolversTypes['Ledger'], ParentType, ContextType>;
  metadata?: Resolver<Maybe<ResolversTypes['ChargeMetadata']>, ParentType, ContextType>;
  minDebitDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minDocumentsDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minEventDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  miscExpenses?: Resolver<ReadonlyArray<ResolversTypes['MiscExpense']>, ParentType, ContextType>;
  missingInfoSuggestions?: Resolver<Maybe<ResolversTypes['ChargeSuggestions']>, ParentType, ContextType>;
  optionalVAT?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  owner?: Resolver<ResolversTypes['Business'], ParentType, ContextType>;
  property?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  salary?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  tags?: Resolver<ReadonlyArray<ResolversTypes['Tag']>, ParentType, ContextType>;
  taxCategory?: Resolver<Maybe<ResolversTypes['TaxCategory']>, ParentType, ContextType>;
  totalAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  transactions?: Resolver<ReadonlyArray<ResolversTypes['Transaction']>, ParentType, ContextType>;
  userDescription?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  validationData?: Resolver<Maybe<ResolversTypes['ValidationData']>, ParentType, ContextType>;
  vat?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  withholdingTax?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  yearsOfRelevance?: Resolver<Maybe<ReadonlyArray<ResolversTypes['YearOfRelevance']>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type InvoiceResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['Invoice'] = ResolversParentTypes['Invoice']> = {
  amount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  charge?: Resolver<Maybe<ResolversTypes['Charge']>, ParentType, ContextType>;
  creditor?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  date?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  debtor?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  documentType?: Resolver<Maybe<ResolversTypes['DocumentType']>, ParentType, ContextType>;
  file?: Resolver<Maybe<ResolversTypes['URL']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  image?: Resolver<Maybe<ResolversTypes['URL']>, ParentType, ContextType>;
  isReviewed?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  missingInfoSuggestions?: Resolver<Maybe<ResolversTypes['DocumentSuggestions']>, ParentType, ContextType>;
  noVatAmount?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  serialNumber?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  vat?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  vatReportDateOverride?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type InvoiceReceiptResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['InvoiceReceipt'] = ResolversParentTypes['InvoiceReceipt']> = {
  amount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  charge?: Resolver<Maybe<ResolversTypes['Charge']>, ParentType, ContextType>;
  creditor?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  date?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  debtor?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  documentType?: Resolver<Maybe<ResolversTypes['DocumentType']>, ParentType, ContextType>;
  file?: Resolver<Maybe<ResolversTypes['URL']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  image?: Resolver<Maybe<ResolversTypes['URL']>, ParentType, ContextType>;
  isReviewed?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  missingInfoSuggestions?: Resolver<Maybe<ResolversTypes['DocumentSuggestions']>, ParentType, ContextType>;
  noVatAmount?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  serialNumber?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  vat?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  vatReportDateOverride?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type LedgerResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['Ledger'] = ResolversParentTypes['Ledger']> = {
  balance?: Resolver<Maybe<ResolversTypes['LedgerBalanceInfo']>, ParentType, ContextType>;
  records?: Resolver<ReadonlyArray<ResolversTypes['LedgerRecord']>, ParentType, ContextType>;
  validate?: Resolver<ResolversTypes['LedgerValidation'], ParentType, ContextType, Partial<LedgerValidateArgs>>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type LedgerBalanceInfoResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['LedgerBalanceInfo'] = ResolversParentTypes['LedgerBalanceInfo']> = {
  isBalanced?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
  unbalancedEntities?: Resolver<ReadonlyArray<ResolversTypes['LedgerBalanceUnbalancedEntity']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type LedgerBalanceUnbalancedEntityResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['LedgerBalanceUnbalancedEntity'] = ResolversParentTypes['LedgerBalanceUnbalancedEntity']> = {
  balance?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  entity?: Resolver<ResolversTypes['FinancialEntity'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type LedgerRecordResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['LedgerRecord'] = ResolversParentTypes['LedgerRecord']> = {
  creditAccount1?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  creditAccount2?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  creditAmount1?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  creditAmount2?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  debitAccount1?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  debitAccount2?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  debitAmount1?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  debitAmount2?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  description?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  invoiceDate?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
  localCurrencyCreditAmount1?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  localCurrencyCreditAmount2?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  localCurrencyDebitAmount1?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  localCurrencyDebitAmount2?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  reference?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  valueDate?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type LedgerValidationResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['LedgerValidation'] = ResolversParentTypes['LedgerValidation']> = {
  differences?: Resolver<ReadonlyArray<ResolversTypes['LedgerRecord']>, ParentType, ContextType>;
  errors?: Resolver<ReadonlyArray<ResolversTypes['String']>, ParentType, ContextType>;
  isValid?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
  matches?: Resolver<ReadonlyArray<ResolversTypes['UUID']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type LinkableResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['Linkable'] = ResolversParentTypes['Linkable']> = {
  __resolveType?: TypeResolveFn<'CreditInvoice' | 'Invoice' | 'InvoiceReceipt' | 'OtherDocument' | 'Proforma' | 'Receipt' | 'Unprocessed', ParentType, ContextType>;
  file?: Resolver<Maybe<ResolversTypes['URL']>, ParentType, ContextType>;
};

export type LtdFinancialEntityResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['LtdFinancialEntity'] = ResolversParentTypes['LtdFinancialEntity']> = {
  accounts?: Resolver<ReadonlyArray<ResolversTypes['FinancialAccount']>, ParentType, ContextType>;
  address?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  charges?: Resolver<ResolversTypes['PaginatedCharges'], ParentType, ContextType, RequireFields<LtdFinancialEntityChargesArgs, 'limit' | 'page'>>;
  country?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  email?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  exemptDealer?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  governmentId?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  hebrewName?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  optionalVAT?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  phoneNumber?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  sortCode?: Resolver<Maybe<ResolversTypes['SortCode']>, ParentType, ContextType>;
  suggestions?: Resolver<Maybe<ResolversTypes['Suggestions']>, ParentType, ContextType>;
  taxCategory?: Resolver<Maybe<ResolversTypes['TaxCategory']>, ParentType, ContextType>;
  website?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type MergeChargeResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['MergeChargeResult'] = ResolversParentTypes['MergeChargeResult']> = {
  __resolveType?: TypeResolveFn<'CommonError' | 'MergeChargeSuccessfulResult', ParentType, ContextType>;
};

export type MergeChargeSuccessfulResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['MergeChargeSuccessfulResult'] = ResolversParentTypes['MergeChargeSuccessfulResult']> = {
  charge?: Resolver<ResolversTypes['Charge'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type MergeChargesByTransactionReferenceResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['MergeChargesByTransactionReferenceResult'] = ResolversParentTypes['MergeChargesByTransactionReferenceResult']> = {
  charges?: Resolver<Maybe<ReadonlyArray<ResolversTypes['Charge']>>, ParentType, ContextType>;
  errors?: Resolver<Maybe<ReadonlyArray<ResolversTypes['String']>>, ParentType, ContextType>;
  success?: Resolver<ResolversTypes['Boolean'], 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>;
  chargeId?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  creditor?: Resolver<ResolversTypes['FinancialEntity'], ParentType, ContextType>;
  debtor?: Resolver<ResolversTypes['FinancialEntity'], ParentType, ContextType>;
  description?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  invoiceDate?: Resolver<ResolversTypes['TimelessDate'], ParentType, ContextType>;
  valueDate?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type MissingChargeInfoResolvers = EnumResolverSignature<{ COUNTERPARTY?: any, DESCRIPTION?: any, DOCUMENTS?: any, TAGS?: any, TAX_CATEGORY?: any, TRANSACTIONS?: any, VAT?: any }, ResolversTypes['MissingChargeInfo']>;

export type MonthlyVatChargeResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['MonthlyVatCharge'] = ResolversParentTypes['MonthlyVatCharge']> = {
  accountantApproval?: Resolver<ResolversTypes['AccountantStatus'], ParentType, ContextType>;
  additionalDocuments?: Resolver<ReadonlyArray<ResolversTypes['Document']>, ParentType, ContextType>;
  conversion?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  counterparty?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  exchangeRates?: Resolver<Maybe<ResolversTypes['ExchangeRates']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  isInvoicePaymentDifferentCurrency?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  ledger?: Resolver<ResolversTypes['Ledger'], ParentType, ContextType>;
  metadata?: Resolver<Maybe<ResolversTypes['ChargeMetadata']>, ParentType, ContextType>;
  minDebitDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minDocumentsDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minEventDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  miscExpenses?: Resolver<ReadonlyArray<ResolversTypes['MiscExpense']>, ParentType, ContextType>;
  missingInfoSuggestions?: Resolver<Maybe<ResolversTypes['ChargeSuggestions']>, ParentType, ContextType>;
  optionalVAT?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  owner?: Resolver<ResolversTypes['Business'], ParentType, ContextType>;
  property?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  salary?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  tags?: Resolver<ReadonlyArray<ResolversTypes['Tag']>, ParentType, ContextType>;
  taxCategory?: Resolver<Maybe<ResolversTypes['TaxCategory']>, ParentType, ContextType>;
  totalAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  transactions?: Resolver<ReadonlyArray<ResolversTypes['Transaction']>, ParentType, ContextType>;
  userDescription?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  validationData?: Resolver<Maybe<ResolversTypes['ValidationData']>, ParentType, ContextType>;
  vat?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  withholdingTax?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  yearsOfRelevance?: Resolver<Maybe<ReadonlyArray<ResolversTypes['YearOfRelevance']>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type MutationResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['Mutation'] = ResolversParentTypes['Mutation']> = {
  addBusinessTripAccommodationsExpense?: Resolver<ResolversTypes['UUID'], ParentType, ContextType, RequireFields<MutationAddBusinessTripAccommodationsExpenseArgs, 'fields'>>;
  addBusinessTripCarRentalExpense?: Resolver<ResolversTypes['UUID'], ParentType, ContextType, RequireFields<MutationAddBusinessTripCarRentalExpenseArgs, 'fields'>>;
  addBusinessTripFlightsExpense?: Resolver<ResolversTypes['UUID'], ParentType, ContextType, RequireFields<MutationAddBusinessTripFlightsExpenseArgs, 'fields'>>;
  addBusinessTripOtherExpense?: Resolver<ResolversTypes['UUID'], ParentType, ContextType, RequireFields<MutationAddBusinessTripOtherExpenseArgs, 'fields'>>;
  addBusinessTripTravelAndSubsistenceExpense?: Resolver<ResolversTypes['UUID'], ParentType, ContextType, RequireFields<MutationAddBusinessTripTravelAndSubsistenceExpenseArgs, 'fields'>>;
  addTag?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType, RequireFields<MutationAddTagArgs, 'name'>>;
  batchGenerateBusinessesOutOfTransactions?: Resolver<ReadonlyArray<ResolversTypes['Business']>, ParentType, ContextType>;
  batchUploadDocuments?: Resolver<ReadonlyArray<ResolversTypes['UploadDocumentResult']>, ParentType, ContextType, RequireFields<MutationBatchUploadDocumentsArgs, 'documents'>>;
  batchUploadDocumentsFromGoogleDrive?: Resolver<ReadonlyArray<ResolversTypes['UploadDocumentResult']>, ParentType, ContextType, RequireFields<MutationBatchUploadDocumentsFromGoogleDriveArgs, 'sharedFolderUrl'>>;
  categorizeBusinessTripExpense?: Resolver<ResolversTypes['UUID'], ParentType, ContextType, RequireFields<MutationCategorizeBusinessTripExpenseArgs, 'fields'>>;
  categorizeIntoExistingBusinessTripExpense?: Resolver<ResolversTypes['UUID'], ParentType, ContextType, RequireFields<MutationCategorizeIntoExistingBusinessTripExpenseArgs, 'fields'>>;
  creditShareholdersBusinessTripTravelAndSubsistence?: Resolver<ReadonlyArray<ResolversTypes['UUID']>, ParentType, ContextType, RequireFields<MutationCreditShareholdersBusinessTripTravelAndSubsistenceArgs, 'businessTripId'>>;
  deleteBusinessTripAttendee?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType, RequireFields<MutationDeleteBusinessTripAttendeeArgs, 'fields'>>;
  deleteBusinessTripExpense?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType, RequireFields<MutationDeleteBusinessTripExpenseArgs, 'businessTripExpenseId'>>;
  deleteCharge?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType, RequireFields<MutationDeleteChargeArgs, 'chargeId'>>;
  deleteDepreciationCategory?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType, RequireFields<MutationDeleteDepreciationCategoryArgs, 'depreciationCategoryId'>>;
  deleteDepreciationRecord?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType, RequireFields<MutationDeleteDepreciationRecordArgs, 'depreciationRecordId'>>;
  deleteDocument?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType, RequireFields<MutationDeleteDocumentArgs, 'documentId'>>;
  deleteDynamicReportTemplate?: Resolver<ResolversTypes['String'], ParentType, ContextType, RequireFields<MutationDeleteDynamicReportTemplateArgs, 'name'>>;
  deleteMiscExpense?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType, RequireFields<MutationDeleteMiscExpenseArgs, 'id'>>;
  deleteTag?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType, RequireFields<MutationDeleteTagArgs, 'id'>>;
  fetchIncomeDocuments?: Resolver<ReadonlyArray<ResolversTypes['Document']>, ParentType, ContextType, RequireFields<MutationFetchIncomeDocumentsArgs, 'ownerId'>>;
  flagForeignFeeTransactions?: Resolver<ResolversTypes['FlagForeignFeeTransactionsResult'], ParentType, ContextType>;
  generateBankDepositsRevaluationCharge?: Resolver<ResolversTypes['FinancialCharge'], ParentType, ContextType, RequireFields<MutationGenerateBankDepositsRevaluationChargeArgs, 'date' | 'ownerId'>>;
  generateDepreciationCharge?: Resolver<ResolversTypes['FinancialCharge'], ParentType, ContextType, RequireFields<MutationGenerateDepreciationChargeArgs, 'ownerId' | 'year'>>;
  generateMonthlyClientDocuments?: Resolver<ResolversTypes['GenerateMonthlyClientDocumentsResult'], ParentType, ContextType>;
  generateRecoveryReserveCharge?: Resolver<ResolversTypes['FinancialCharge'], ParentType, ContextType, RequireFields<MutationGenerateRecoveryReserveChargeArgs, 'ownerId' | 'year'>>;
  generateRevaluationCharge?: Resolver<ResolversTypes['FinancialCharge'], ParentType, ContextType, RequireFields<MutationGenerateRevaluationChargeArgs, 'date' | 'ownerId'>>;
  generateTaxExpensesCharge?: Resolver<ResolversTypes['FinancialCharge'], ParentType, ContextType, RequireFields<MutationGenerateTaxExpensesChargeArgs, 'ownerId' | 'year'>>;
  generateVacationReserveCharge?: Resolver<ResolversTypes['FinancialCharge'], ParentType, ContextType, RequireFields<MutationGenerateVacationReserveChargeArgs, 'ownerId' | 'year'>>;
  insertBusinessTrip?: Resolver<ResolversTypes['UUID'], ParentType, ContextType, RequireFields<MutationInsertBusinessTripArgs, 'fields'>>;
  insertBusinessTripAttendee?: Resolver<ResolversTypes['UUID'], ParentType, ContextType, RequireFields<MutationInsertBusinessTripAttendeeArgs, 'fields'>>;
  insertDepreciationCategory?: Resolver<ResolversTypes['InsertDepreciationCategoryResult'], ParentType, ContextType, RequireFields<MutationInsertDepreciationCategoryArgs, 'input'>>;
  insertDepreciationRecord?: Resolver<ResolversTypes['InsertDepreciationRecordResult'], ParentType, ContextType, RequireFields<MutationInsertDepreciationRecordArgs, 'input'>>;
  insertDocument?: Resolver<ResolversTypes['InsertDocumentResult'], ParentType, ContextType, RequireFields<MutationInsertDocumentArgs, 'record'>>;
  insertDynamicReportTemplate?: Resolver<ResolversTypes['DynamicReportInfo'], ParentType, ContextType, RequireFields<MutationInsertDynamicReportTemplateArgs, 'name' | 'template'>>;
  insertMiscExpense?: Resolver<ResolversTypes['MiscExpense'], ParentType, ContextType, RequireFields<MutationInsertMiscExpenseArgs, 'fields'>>;
  insertNewBusiness?: Resolver<ResolversTypes['UpdateBusinessResponse'], ParentType, ContextType, RequireFields<MutationInsertNewBusinessArgs, 'fields'>>;
  insertOrUpdateSalaryRecords?: Resolver<ResolversTypes['InsertSalaryRecordsResult'], ParentType, ContextType, RequireFields<MutationInsertOrUpdateSalaryRecordsArgs, 'salaryRecords'>>;
  insertSalaryRecords?: Resolver<ResolversTypes['InsertSalaryRecordsResult'], ParentType, ContextType, RequireFields<MutationInsertSalaryRecordsArgs, 'salaryRecords'>>;
  insertSalaryRecordsFromFile?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType, RequireFields<MutationInsertSalaryRecordsFromFileArgs, 'chargeId' | 'file'>>;
  insertTaxCategory?: Resolver<ResolversTypes['TaxCategory'], ParentType, ContextType, RequireFields<MutationInsertTaxCategoryArgs, 'fields'>>;
  mergeBusinesses?: Resolver<ResolversTypes['Business'], ParentType, ContextType, RequireFields<MutationMergeBusinessesArgs, 'businessIdsToMerge' | 'targetBusinessId'>>;
  mergeCharges?: Resolver<ResolversTypes['MergeChargeResult'], ParentType, ContextType, RequireFields<MutationMergeChargesArgs, 'baseChargeID' | 'chargeIdsToMerge'>>;
  mergeChargesByTransactionReference?: Resolver<ResolversTypes['MergeChargesByTransactionReferenceResult'], ParentType, ContextType>;
  pong?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  regenerateLedgerRecords?: Resolver<ResolversTypes['GeneratedLedgerRecords'], ParentType, ContextType, RequireFields<MutationRegenerateLedgerRecordsArgs, 'chargeId'>>;
  uncategorizePartialBusinessTripExpense?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType, RequireFields<MutationUncategorizePartialBusinessTripExpenseArgs, 'businessTripExpenseId' | 'transactionId'>>;
  updateBusiness?: Resolver<ResolversTypes['UpdateBusinessResponse'], ParentType, ContextType, RequireFields<MutationUpdateBusinessArgs, 'businessId' | 'fields' | 'ownerId'>>;
  updateBusinessTrip?: Resolver<ResolversTypes['UUID'], ParentType, ContextType, RequireFields<MutationUpdateBusinessTripArgs, 'fields'>>;
  updateBusinessTripAccommodationsExpense?: Resolver<ResolversTypes['UUID'], ParentType, ContextType, RequireFields<MutationUpdateBusinessTripAccommodationsExpenseArgs, 'fields'>>;
  updateBusinessTripAccountantApproval?: Resolver<ResolversTypes['AccountantStatus'], ParentType, ContextType, RequireFields<MutationUpdateBusinessTripAccountantApprovalArgs, 'approvalStatus' | 'businessTripId'>>;
  updateBusinessTripAttendee?: Resolver<ResolversTypes['UUID'], ParentType, ContextType, RequireFields<MutationUpdateBusinessTripAttendeeArgs, 'fields'>>;
  updateBusinessTripCarRentalExpense?: Resolver<ResolversTypes['UUID'], ParentType, ContextType, RequireFields<MutationUpdateBusinessTripCarRentalExpenseArgs, 'fields'>>;
  updateBusinessTripFlightsExpense?: Resolver<ResolversTypes['UUID'], ParentType, ContextType, RequireFields<MutationUpdateBusinessTripFlightsExpenseArgs, 'fields'>>;
  updateBusinessTripOtherExpense?: Resolver<ResolversTypes['UUID'], ParentType, ContextType, RequireFields<MutationUpdateBusinessTripOtherExpenseArgs, 'fields'>>;
  updateBusinessTripTravelAndSubsistenceExpense?: Resolver<ResolversTypes['UUID'], ParentType, ContextType, RequireFields<MutationUpdateBusinessTripTravelAndSubsistenceExpenseArgs, 'fields'>>;
  updateCharge?: Resolver<ResolversTypes['UpdateChargeResult'], ParentType, ContextType, RequireFields<MutationUpdateChargeArgs, 'chargeId' | 'fields'>>;
  updateChargeAccountantApproval?: Resolver<ResolversTypes['AccountantStatus'], ParentType, ContextType, RequireFields<MutationUpdateChargeAccountantApprovalArgs, 'approvalStatus' | 'chargeId'>>;
  updateChargeBusinessTrip?: Resolver<Maybe<ResolversTypes['Charge']>, ParentType, ContextType, RequireFields<MutationUpdateChargeBusinessTripArgs, 'chargeId'>>;
  updateDepreciationCategory?: Resolver<ResolversTypes['UpdateDepreciationCategoryResult'], ParentType, ContextType, RequireFields<MutationUpdateDepreciationCategoryArgs, 'input'>>;
  updateDepreciationRecord?: Resolver<ResolversTypes['UpdateDepreciationRecordResult'], ParentType, ContextType, RequireFields<MutationUpdateDepreciationRecordArgs, 'input'>>;
  updateDocument?: Resolver<ResolversTypes['UpdateDocumentResult'], ParentType, ContextType, RequireFields<MutationUpdateDocumentArgs, 'documentId' | 'fields'>>;
  updateDynamicReportTemplate?: Resolver<ResolversTypes['DynamicReportInfo'], ParentType, ContextType, RequireFields<MutationUpdateDynamicReportTemplateArgs, 'name' | 'template'>>;
  updateDynamicReportTemplateName?: Resolver<ResolversTypes['DynamicReportInfo'], ParentType, ContextType, RequireFields<MutationUpdateDynamicReportTemplateNameArgs, 'name' | 'newName'>>;
  updateMiscExpense?: Resolver<ResolversTypes['MiscExpense'], ParentType, ContextType, RequireFields<MutationUpdateMiscExpenseArgs, 'fields' | 'id'>>;
  updateSalaryRecord?: Resolver<ResolversTypes['UpdateSalaryRecordResult'], ParentType, ContextType, RequireFields<MutationUpdateSalaryRecordArgs, 'salaryRecord'>>;
  updateTag?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType, RequireFields<MutationUpdateTagArgs, 'fields' | 'id'>>;
  updateTagParent?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType, RequireFields<MutationUpdateTagParentArgs, 'id'>>;
  updateTagPart?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType, RequireFields<MutationUpdateTagPartArgs, 'chargeId' | 'part' | 'tagId'>>;
  updateTaxCategory?: Resolver<ResolversTypes['UpdateTaxCategoryResponse'], ParentType, ContextType, RequireFields<MutationUpdateTaxCategoryArgs, 'fields' | 'taxCategoryId'>>;
  updateTransaction?: Resolver<ResolversTypes['UpdateTransactionResult'], ParentType, ContextType, RequireFields<MutationUpdateTransactionArgs, 'fields' | 'transactionId'>>;
  uploadDocument?: Resolver<ResolversTypes['UploadDocumentResult'], ParentType, ContextType, RequireFields<MutationUploadDocumentArgs, 'file'>>;
};

export type OtherDocumentResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['OtherDocument'] = ResolversParentTypes['OtherDocument']> = {
  charge?: Resolver<Maybe<ResolversTypes['Charge']>, ParentType, ContextType>;
  documentType?: Resolver<Maybe<ResolversTypes['DocumentType']>, ParentType, ContextType>;
  file?: Resolver<Maybe<ResolversTypes['URL']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  image?: Resolver<Maybe<ResolversTypes['URL']>, ParentType, ContextType>;
  isReviewed?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type PcnFileResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['PCNFileResult'] = ResolversParentTypes['PCNFileResult']> = {
  fileName?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  reportContent?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type PageInfoResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['PageInfo'] = ResolversParentTypes['PageInfo']> = {
  currentPage?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  pageSize?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  totalPages?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type PaginatedBusinessesResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['PaginatedBusinesses'] = ResolversParentTypes['PaginatedBusinesses']> = {
  nodes?: Resolver<ReadonlyArray<ResolversTypes['Business']>, ParentType, ContextType>;
  pageInfo?: Resolver<ResolversTypes['PageInfo'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type PaginatedChargesResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['PaginatedCharges'] = ResolversParentTypes['PaginatedCharges']> = {
  nodes?: Resolver<ReadonlyArray<ResolversTypes['Charge']>, ParentType, ContextType>;
  pageInfo?: Resolver<ResolversTypes['PageInfo'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type PaginatedFinancialEntitiesResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['PaginatedFinancialEntities'] = ResolversParentTypes['PaginatedFinancialEntities']> = {
  nodes?: Resolver<ReadonlyArray<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  pageInfo?: Resolver<ResolversTypes['PageInfo'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type PensionFundResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['PensionFund'] = ResolversParentTypes['PensionFund']> = {
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type PersonalFinancialEntityResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['PersonalFinancialEntity'] = ResolversParentTypes['PersonalFinancialEntity']> = {
  accounts?: Resolver<ReadonlyArray<ResolversTypes['FinancialAccount']>, ParentType, ContextType>;
  charges?: Resolver<ResolversTypes['PaginatedCharges'], ParentType, ContextType, RequireFields<PersonalFinancialEntityChargesArgs, 'limit' | 'page'>>;
  email?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  sortCode?: Resolver<Maybe<ResolversTypes['SortCode']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ProfitAndLossReportResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['ProfitAndLossReport'] = ResolversParentTypes['ProfitAndLossReport']> = {
  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  reference?: Resolver<ReadonlyArray<ResolversTypes['ProfitAndLossReportYear']>, ParentType, ContextType>;
  report?: Resolver<ResolversTypes['ProfitAndLossReportYear'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ProfitAndLossReportYearResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['ProfitAndLossReportYear'] = ResolversParentTypes['ProfitAndLossReportYear']> = {
  costOfSales?: Resolver<ResolversTypes['ReportCommentary'], ParentType, ContextType>;
  financialExpenses?: Resolver<ResolversTypes['ReportCommentary'], ParentType, ContextType>;
  grossProfit?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  managementAndGeneralExpenses?: Resolver<ResolversTypes['ReportCommentary'], ParentType, ContextType>;
  marketingExpenses?: Resolver<ResolversTypes['ReportCommentary'], ParentType, ContextType>;
  netProfit?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  operatingProfit?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  otherIncome?: Resolver<ResolversTypes['ReportCommentary'], ParentType, ContextType>;
  profitBeforeTax?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  researchAndDevelopmentExpenses?: Resolver<ResolversTypes['ReportCommentary'], ParentType, ContextType>;
  revenue?: Resolver<ResolversTypes['ReportCommentary'], ParentType, ContextType>;
  tax?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  year?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ProformaResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['Proforma'] = ResolversParentTypes['Proforma']> = {
  amount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  charge?: Resolver<Maybe<ResolversTypes['Charge']>, ParentType, ContextType>;
  creditor?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  date?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  debtor?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  documentType?: Resolver<Maybe<ResolversTypes['DocumentType']>, ParentType, ContextType>;
  file?: Resolver<Maybe<ResolversTypes['URL']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  image?: Resolver<Maybe<ResolversTypes['URL']>, ParentType, ContextType>;
  isReviewed?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  missingInfoSuggestions?: Resolver<Maybe<ResolversTypes['DocumentSuggestions']>, ParentType, ContextType>;
  noVatAmount?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  serialNumber?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  vat?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  vatReportDateOverride?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type QueryResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = {
  allBusinessTrips?: Resolver<ReadonlyArray<ResolversTypes['BusinessTrip']>, ParentType, ContextType>;
  allBusinesses?: Resolver<Maybe<ResolversTypes['PaginatedBusinesses']>, ParentType, ContextType, Partial<QueryAllBusinessesArgs>>;
  allCharges?: Resolver<ResolversTypes['PaginatedCharges'], ParentType, ContextType, RequireFields<QueryAllChargesArgs, 'limit' | 'page'>>;
  allCountries?: Resolver<ReadonlyArray<ResolversTypes['Country']>, ParentType, ContextType>;
  allDynamicReports?: Resolver<ReadonlyArray<ResolversTypes['DynamicReportInfo']>, ParentType, ContextType>;
  allFinancialAccounts?: Resolver<ReadonlyArray<ResolversTypes['FinancialAccount']>, ParentType, ContextType>;
  allFinancialEntities?: Resolver<Maybe<ResolversTypes['PaginatedFinancialEntities']>, ParentType, ContextType, Partial<QueryAllFinancialEntitiesArgs>>;
  allPensionFunds?: Resolver<ReadonlyArray<ResolversTypes['PensionFund']>, ParentType, ContextType>;
  allSortCodes?: Resolver<ReadonlyArray<ResolversTypes['SortCode']>, ParentType, ContextType>;
  allTags?: Resolver<ReadonlyArray<ResolversTypes['Tag']>, ParentType, ContextType>;
  allTrainingFunds?: Resolver<ReadonlyArray<ResolversTypes['TrainingFund']>, ParentType, ContextType>;
  business?: Resolver<ResolversTypes['Business'], ParentType, ContextType, RequireFields<QueryBusinessArgs, 'id'>>;
  businessTransactionsFromLedgerRecords?: Resolver<ResolversTypes['BusinessTransactionsFromLedgerRecordsResult'], ParentType, ContextType, Partial<QueryBusinessTransactionsFromLedgerRecordsArgs>>;
  businessTransactionsSumFromLedgerRecords?: Resolver<ResolversTypes['BusinessTransactionsSumFromLedgerRecordsResult'], ParentType, ContextType, Partial<QueryBusinessTransactionsSumFromLedgerRecordsArgs>>;
  businessTrip?: Resolver<Maybe<ResolversTypes['BusinessTrip']>, ParentType, ContextType, RequireFields<QueryBusinessTripArgs, 'id'>>;
  businesses?: Resolver<ReadonlyArray<ResolversTypes['Business']>, ParentType, ContextType, RequireFields<QueryBusinessesArgs, 'ids'>>;
  chargesByIDs?: Resolver<ReadonlyArray<ResolversTypes['Charge']>, ParentType, ContextType, RequireFields<QueryChargesByIDsArgs, 'chargeIDs'>>;
  chargesWithLedgerChanges?: Resolver<ReadonlyArray<ResolversTypes['ChargesWithLedgerChangesResult']>, ParentType, ContextType, Partial<QueryChargesWithLedgerChangesArgs>>;
  chargesWithMissingRequiredInfo?: Resolver<ResolversTypes['PaginatedCharges'], ParentType, ContextType, RequireFields<QueryChargesWithMissingRequiredInfoArgs, 'limit' | 'page'>>;
  corporateTaxByDate?: Resolver<ResolversTypes['CorporateTax'], ParentType, ContextType, RequireFields<QueryCorporateTaxByDateArgs, 'date'>>;
  corporateTaxRulingComplianceReport?: Resolver<ReadonlyArray<ResolversTypes['CorporateTaxRulingComplianceReport']>, ParentType, ContextType, RequireFields<QueryCorporateTaxRulingComplianceReportArgs, 'years'>>;
  depreciationCategories?: Resolver<ReadonlyArray<ResolversTypes['DepreciationCategory']>, ParentType, ContextType>;
  depreciationRecordsByCharge?: Resolver<ReadonlyArray<ResolversTypes['DepreciationRecord']>, ParentType, ContextType, RequireFields<QueryDepreciationRecordsByChargeArgs, 'chargeId'>>;
  documentById?: Resolver<Maybe<ResolversTypes['Document']>, ParentType, ContextType, RequireFields<QueryDocumentByIdArgs, 'documentId'>>;
  documents?: Resolver<ReadonlyArray<ResolversTypes['Document']>, ParentType, ContextType>;
  documentsByFilters?: Resolver<ReadonlyArray<ResolversTypes['Document']>, ParentType, ContextType, RequireFields<QueryDocumentsByFiltersArgs, 'filters'>>;
  dynamicReport?: Resolver<ResolversTypes['DynamicReportInfo'], ParentType, ContextType, RequireFields<QueryDynamicReportArgs, 'name'>>;
  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'>>;
  incomeExpenseChart?: Resolver<ResolversTypes['IncomeExpenseChart'], ParentType, ContextType, RequireFields<QueryIncomeExpenseChartArgs, 'filters'>>;
  ledgerRecordsByDates?: Resolver<ReadonlyArray<ResolversTypes['LedgerRecord']>, ParentType, ContextType, RequireFields<QueryLedgerRecordsByDatesArgs, 'fromDate' | 'toDate'>>;
  miscExpensesByCharge?: Resolver<ReadonlyArray<ResolversTypes['MiscExpense']>, ParentType, ContextType, RequireFields<QueryMiscExpensesByChargeArgs, 'chargeId'>>;
  pcnFile?: Resolver<ResolversTypes['PCNFileResult'], ParentType, ContextType, RequireFields<QueryPcnFileArgs, 'financialEntityId' | 'fromDate' | 'toDate'>>;
  ping?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  profitAndLossReport?: Resolver<ResolversTypes['ProfitAndLossReport'], ParentType, ContextType, RequireFields<QueryProfitAndLossReportArgs, 'referenceYears' | 'reportYear'>>;
  salaryRecordsByCharge?: Resolver<ReadonlyArray<ResolversTypes['Salary']>, ParentType, ContextType, RequireFields<QuerySalaryRecordsByChargeArgs, 'chargeId'>>;
  salaryRecordsByDates?: Resolver<ReadonlyArray<ResolversTypes['Salary']>, ParentType, ContextType, RequireFields<QuerySalaryRecordsByDatesArgs, 'fromDate' | 'toDate'>>;
  similarTransactions?: Resolver<ReadonlyArray<ResolversTypes['Transaction']>, ParentType, ContextType, RequireFields<QuerySimilarTransactionsArgs, 'transactionId'>>;
  taxCategories?: Resolver<ReadonlyArray<ResolversTypes['TaxCategory']>, ParentType, ContextType>;
  taxCategory?: Resolver<ResolversTypes['TaxCategory'], ParentType, ContextType, RequireFields<QueryTaxCategoryArgs, 'id'>>;
  taxCategoryByBusinessId?: Resolver<Maybe<ResolversTypes['TaxCategory']>, ParentType, ContextType, RequireFields<QueryTaxCategoryByBusinessIdArgs, 'businessId' | 'ownerId'>>;
  taxReport?: Resolver<ResolversTypes['TaxReport'], ParentType, ContextType, RequireFields<QueryTaxReportArgs, 'referenceYears' | 'reportYear'>>;
  transactionsByIDs?: Resolver<ReadonlyArray<ResolversTypes['Transaction']>, ParentType, ContextType, RequireFields<QueryTransactionsByIDsArgs, 'transactionIDs'>>;
  vatReport?: Resolver<ResolversTypes['VatReportResult'], ParentType, ContextType, Partial<QueryVatReportArgs>>;
  yearlyLedgerReport?: Resolver<ResolversTypes['YearlyLedgerReport'], ParentType, ContextType, RequireFields<QueryYearlyLedgerReportArgs, 'year'>>;
};

export interface RateScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['Rate'], any> {
  name: 'Rate';
}

export type ReceiptResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['Receipt'] = ResolversParentTypes['Receipt']> = {
  amount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  charge?: Resolver<Maybe<ResolversTypes['Charge']>, ParentType, ContextType>;
  creditor?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  date?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  debtor?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  documentType?: Resolver<Maybe<ResolversTypes['DocumentType']>, ParentType, ContextType>;
  file?: Resolver<Maybe<ResolversTypes['URL']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  image?: Resolver<Maybe<ResolversTypes['URL']>, ParentType, ContextType>;
  isReviewed?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  missingInfoSuggestions?: Resolver<Maybe<ResolversTypes['DocumentSuggestions']>, ParentType, ContextType>;
  noVatAmount?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  serialNumber?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  vat?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  vatReportDateOverride?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ReportCommentaryResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['ReportCommentary'] = ResolversParentTypes['ReportCommentary']> = {
  amount?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  records?: Resolver<ReadonlyArray<ResolversTypes['ReportCommentaryRecord']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ReportCommentaryRecordResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['ReportCommentaryRecord'] = ResolversParentTypes['ReportCommentaryRecord']> = {
  amount?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  records?: Resolver<ReadonlyArray<ResolversTypes['ReportCommentarySubRecord']>, ParentType, ContextType>;
  sortCode?: Resolver<ResolversTypes['SortCode'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ReportCommentarySubRecordResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['ReportCommentarySubRecord'] = ResolversParentTypes['ReportCommentarySubRecord']> = {
  amount?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  financialEntity?: Resolver<ResolversTypes['FinancialEntity'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type SalaryResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['Salary'] = ResolversParentTypes['Salary']> = {
  baseAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  bonus?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  charge?: Resolver<Maybe<ResolversTypes['SalaryCharge']>, ParentType, ContextType>;
  compensationsAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  compensationsPercentage?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  directAmount?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  employee?: Resolver<Maybe<ResolversTypes['LtdFinancialEntity']>, ParentType, ContextType>;
  employer?: Resolver<Maybe<ResolversTypes['LtdFinancialEntity']>, ParentType, ContextType>;
  gift?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  globalAdditionalHoursAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  healthInsuranceAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  incomeTaxAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  month?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  notionalExpense?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  pensionEmployeeAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  pensionEmployeePercentage?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  pensionEmployerAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  pensionEmployerPercentage?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  pensionFund?: Resolver<Maybe<ResolversTypes['LtdFinancialEntity']>, ParentType, ContextType>;
  recovery?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  sicknessDays?: Resolver<Maybe<ResolversTypes['SicknessDays']>, ParentType, ContextType>;
  socialSecurityEmployeeAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  socialSecurityEmployerAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  trainingFund?: Resolver<Maybe<ResolversTypes['LtdFinancialEntity']>, ParentType, ContextType>;
  trainingFundEmployeeAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  trainingFundEmployeePercentage?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  trainingFundEmployerAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  trainingFundEmployerPercentage?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  vacationDays?: Resolver<Maybe<ResolversTypes['VacationDays']>, ParentType, ContextType>;
  vacationTakeout?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  workDays?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type SalaryChargeResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['SalaryCharge'] = ResolversParentTypes['SalaryCharge']> = {
  accountantApproval?: Resolver<ResolversTypes['AccountantStatus'], ParentType, ContextType>;
  additionalDocuments?: Resolver<ReadonlyArray<ResolversTypes['Document']>, ParentType, ContextType>;
  conversion?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  counterparty?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  employees?: Resolver<ReadonlyArray<ResolversTypes['LtdFinancialEntity']>, ParentType, ContextType>;
  exchangeRates?: Resolver<Maybe<ResolversTypes['ExchangeRates']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  isInvoicePaymentDifferentCurrency?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  ledger?: Resolver<ResolversTypes['Ledger'], ParentType, ContextType>;
  metadata?: Resolver<Maybe<ResolversTypes['ChargeMetadata']>, ParentType, ContextType>;
  minDebitDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minDocumentsDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  minEventDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  miscExpenses?: Resolver<ReadonlyArray<ResolversTypes['MiscExpense']>, ParentType, ContextType>;
  missingInfoSuggestions?: Resolver<Maybe<ResolversTypes['ChargeSuggestions']>, ParentType, ContextType>;
  optionalVAT?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  owner?: Resolver<ResolversTypes['Business'], ParentType, ContextType>;
  property?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  salary?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  salaryRecords?: Resolver<ReadonlyArray<ResolversTypes['Salary']>, ParentType, ContextType>;
  tags?: Resolver<ReadonlyArray<ResolversTypes['Tag']>, ParentType, ContextType>;
  taxCategory?: Resolver<Maybe<ResolversTypes['TaxCategory']>, ParentType, ContextType>;
  totalAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  transactions?: Resolver<ReadonlyArray<ResolversTypes['Transaction']>, ParentType, ContextType>;
  userDescription?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  validationData?: Resolver<Maybe<ResolversTypes['ValidationData']>, ParentType, ContextType>;
  vat?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  withholdingTax?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  yearsOfRelevance?: Resolver<Maybe<ReadonlyArray<ResolversTypes['YearOfRelevance']>>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type SicknessDaysResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['SicknessDays'] = ResolversParentTypes['SicknessDays']> = {
  balance?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type SingleSidedLedgerRecordResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['SingleSidedLedgerRecord'] = ResolversParentTypes['SingleSidedLedgerRecord']> = {
  amount?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  balance?: Resolver<ResolversTypes['Float'], ParentType, ContextType>;
  counterParty?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  description?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  invoiceDate?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
  reference?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  valueDate?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type SortCodeResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['SortCode'] = ResolversParentTypes['SortCode']> = {
  id?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type SuggestionsResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['Suggestions'] = ResolversParentTypes['Suggestions']> = {
  description?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  phrases?: Resolver<ReadonlyArray<ResolversTypes['String']>, ParentType, ContextType>;
  tags?: Resolver<ReadonlyArray<ResolversTypes['Tag']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type TagResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['Tag'] = ResolversParentTypes['Tag']> = {
  fullPath?: Resolver<Maybe<ReadonlyArray<ResolversTypes['Tag']>>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  namePath?: Resolver<Maybe<ReadonlyArray<ResolversTypes['String']>>, ParentType, ContextType>;
  parent?: Resolver<Maybe<ResolversTypes['Tag']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type TaxCategoryResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['TaxCategory'] = ResolversParentTypes['TaxCategory']> = {
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  sortCode?: Resolver<Maybe<ResolversTypes['SortCode']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type TaxReportResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['TaxReport'] = ResolversParentTypes['TaxReport']> = {
  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  reference?: Resolver<ReadonlyArray<ResolversTypes['TaxReportYear']>, ParentType, ContextType>;
  report?: Resolver<ResolversTypes['TaxReportYear'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type TaxReportYearResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['TaxReportYear'] = ResolversParentTypes['TaxReportYear']> = {
  annualTaxExpense?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  businessTripsExcessExpensesAmount?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  fines?: Resolver<ResolversTypes['ReportCommentary'], ParentType, ContextType>;
  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  profitBeforeTax?: Resolver<ResolversTypes['ReportCommentary'], ParentType, ContextType>;
  researchAndDevelopmentExpensesByRecords?: Resolver<ResolversTypes['ReportCommentary'], ParentType, ContextType>;
  researchAndDevelopmentExpensesForTax?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  reserves?: Resolver<ResolversTypes['ReportCommentary'], ParentType, ContextType>;
  salaryExcessExpensesAmount?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  taxRate?: Resolver<ResolversTypes['Float'], ParentType, ContextType>;
  taxableIncome?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  untaxableGifts?: Resolver<ResolversTypes['ReportCommentary'], ParentType, ContextType>;
  year?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export interface TimelessDateScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['TimelessDate'], any> {
  name: 'TimelessDate';
}

export type TrainingFundResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['TrainingFund'] = ResolversParentTypes['TrainingFund']> = {
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type TransactionResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['Transaction'] = ResolversParentTypes['Transaction']> = {
  __resolveType?: TypeResolveFn<'CommonTransaction' | 'ConversionTransaction', ParentType, ContextType>;
  account?: Resolver<ResolversTypes['FinancialAccount'], ParentType, ContextType>;
  amount?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  balance?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  chargeId?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  counterparty?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  createdAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
  cryptoExchangeRate?: Resolver<Maybe<ResolversTypes['ConversionRate']>, ParentType, ContextType>;
  debitExchangeRates?: Resolver<Maybe<ResolversTypes['ExchangeRates']>, ParentType, ContextType>;
  direction?: Resolver<ResolversTypes['TransactionDirection'], ParentType, ContextType>;
  effectiveDate?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  eventDate?: Resolver<ResolversTypes['TimelessDate'], ParentType, ContextType>;
  eventExchangeRates?: Resolver<Maybe<ResolversTypes['ExchangeRates']>, ParentType, ContextType>;
  exactEffectiveDate?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  isFee?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  missingInfoSuggestions?: Resolver<Maybe<ResolversTypes['TransactionSuggestions']>, ParentType, ContextType>;
  referenceId?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  referenceKey?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  sourceDescription?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  sourceEffectiveDate?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  updatedAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
};

export type TransactionDirectionResolvers = EnumResolverSignature<{ CREDIT?: any, DEBIT?: any }, ResolversTypes['TransactionDirection']>;

export type TransactionSuggestionsResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['TransactionSuggestions'] = ResolversParentTypes['TransactionSuggestions']> = {
  business?: Resolver<ResolversTypes['FinancialEntity'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export interface UrlScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['URL'], any> {
  name: 'URL';
}

export interface UuidScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['UUID'], any> {
  name: 'UUID';
}

export type UncategorizedTransactionResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['UncategorizedTransaction'] = ResolversParentTypes['UncategorizedTransaction']> = {
  categorizedAmount?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  errors?: Resolver<ReadonlyArray<ResolversTypes['String']>, ParentType, ContextType>;
  transaction?: Resolver<ResolversTypes['Transaction'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type UnprocessedResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['Unprocessed'] = ResolversParentTypes['Unprocessed']> = {
  charge?: Resolver<Maybe<ResolversTypes['Charge']>, ParentType, ContextType>;
  documentType?: Resolver<Maybe<ResolversTypes['DocumentType']>, ParentType, ContextType>;
  file?: Resolver<Maybe<ResolversTypes['URL']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  image?: Resolver<Maybe<ResolversTypes['URL']>, ParentType, ContextType>;
  isReviewed?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type UpdateBusinessResponseResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['UpdateBusinessResponse'] = ResolversParentTypes['UpdateBusinessResponse']> = {
  __resolveType?: TypeResolveFn<'CommonError' | 'LtdFinancialEntity', ParentType, ContextType>;
};

export type UpdateChargeResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['UpdateChargeResult'] = ResolversParentTypes['UpdateChargeResult']> = {
  __resolveType?: TypeResolveFn<'CommonError' | 'UpdateChargeSuccessfulResult', ParentType, ContextType>;
};

export type UpdateChargeSuccessfulResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['UpdateChargeSuccessfulResult'] = ResolversParentTypes['UpdateChargeSuccessfulResult']> = {
  charge?: Resolver<ResolversTypes['Charge'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type UpdateDepreciationCategoryResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['UpdateDepreciationCategoryResult'] = ResolversParentTypes['UpdateDepreciationCategoryResult']> = {
  __resolveType?: TypeResolveFn<'CommonError' | 'DepreciationCategory', ParentType, ContextType>;
};

export type UpdateDepreciationRecordResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['UpdateDepreciationRecordResult'] = ResolversParentTypes['UpdateDepreciationRecordResult']> = {
  __resolveType?: TypeResolveFn<'CommonError' | 'DepreciationRecord', ParentType, ContextType>;
};

export type UpdateDocumentResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['UpdateDocumentResult'] = ResolversParentTypes['UpdateDocumentResult']> = {
  __resolveType?: TypeResolveFn<'CommonError' | 'UpdateDocumentSuccessfulResult', ParentType, ContextType>;
};

export type UpdateDocumentSuccessfulResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['UpdateDocumentSuccessfulResult'] = ResolversParentTypes['UpdateDocumentSuccessfulResult']> = {
  document?: Resolver<Maybe<ResolversTypes['Document']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type UpdateSalaryRecordResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['UpdateSalaryRecordResult'] = ResolversParentTypes['UpdateSalaryRecordResult']> = {
  __resolveType?: TypeResolveFn<'CommonError' | 'UpdateSalaryRecordSuccessfulResult', ParentType, ContextType>;
};

export type UpdateSalaryRecordSuccessfulResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['UpdateSalaryRecordSuccessfulResult'] = ResolversParentTypes['UpdateSalaryRecordSuccessfulResult']> = {
  salaryRecord?: Resolver<ResolversTypes['Salary'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type UpdateTaxCategoryResponseResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['UpdateTaxCategoryResponse'] = ResolversParentTypes['UpdateTaxCategoryResponse']> = {
  __resolveType?: TypeResolveFn<'CommonError' | 'TaxCategory', ParentType, ContextType>;
};

export type UpdateTransactionResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['UpdateTransactionResult'] = ResolversParentTypes['UpdateTransactionResult']> = {
  __resolveType?: TypeResolveFn<'CommonError' | 'CommonTransaction' | 'ConversionTransaction', ParentType, ContextType>;
};

export type UploadDocumentResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['UploadDocumentResult'] = ResolversParentTypes['UploadDocumentResult']> = {
  __resolveType?: TypeResolveFn<'CommonError' | 'UploadDocumentSuccessfulResult', ParentType, ContextType>;
};

export type UploadDocumentSuccessfulResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['UploadDocumentSuccessfulResult'] = ResolversParentTypes['UploadDocumentSuccessfulResult']> = {
  document?: Resolver<Maybe<ResolversTypes['Document']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type VacationDaysResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['VacationDays'] = ResolversParentTypes['VacationDays']> = {
  added?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  balance?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  taken?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type ValidationDataResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['ValidationData'] = ResolversParentTypes['ValidationData']> = {
  balance?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  isValid?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
  missingInfo?: Resolver<ReadonlyArray<ResolversTypes['MissingChargeInfo']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export interface VatMockScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['VatMock'], any> {
  name: 'VatMock';
}

export type VatReportRecordResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['VatReportRecord'] = ResolversParentTypes['VatReportRecord']> = {
  amount?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  business?: Resolver<Maybe<ResolversTypes['FinancialEntity']>, ParentType, ContextType>;
  chargeAccountantStatus?: Resolver<Maybe<ResolversTypes['AccountantStatus']>, ParentType, ContextType>;
  chargeDate?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  chargeId?: Resolver<ResolversTypes['UUID'], ParentType, ContextType>;
  documentDate?: Resolver<Maybe<ResolversTypes['TimelessDate']>, ParentType, ContextType>;
  documentId?: Resolver<Maybe<ResolversTypes['UUID']>, ParentType, ContextType>;
  documentSerial?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  foreignVat?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  foreignVatAfterDeduction?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  image?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  localAmount?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  localVat?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  localVatAfterDeduction?: Resolver<Maybe<ResolversTypes['FinancialAmount']>, ParentType, ContextType>;
  roundedLocalVatAfterDeduction?: Resolver<Maybe<ResolversTypes['FinancialIntAmount']>, ParentType, ContextType>;
  taxReducedForeignAmount?: Resolver<Maybe<ResolversTypes['FinancialIntAmount']>, ParentType, ContextType>;
  taxReducedLocalAmount?: Resolver<Maybe<ResolversTypes['FinancialIntAmount']>, ParentType, ContextType>;
  vatNumber?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type VatReportResultResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['VatReportResult'] = ResolversParentTypes['VatReportResult']> = {
  businessTrips?: Resolver<ReadonlyArray<ResolversTypes['Charge']>, ParentType, ContextType>;
  differentMonthDoc?: Resolver<ReadonlyArray<ResolversTypes['Charge']>, ParentType, ContextType>;
  expenses?: Resolver<ReadonlyArray<ResolversTypes['VatReportRecord']>, ParentType, ContextType>;
  income?: Resolver<ReadonlyArray<ResolversTypes['VatReportRecord']>, ParentType, ContextType>;
  missingInfo?: Resolver<ReadonlyArray<ResolversTypes['Charge']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type YearOfRelevanceResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['YearOfRelevance'] = ResolversParentTypes['YearOfRelevance']> = {
  amount?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  year?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type YearlyLedgerReportResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['YearlyLedgerReport'] = ResolversParentTypes['YearlyLedgerReport']> = {
  financialEntitiesInfo?: Resolver<ReadonlyArray<ResolversTypes['YearlyLedgerReportFinancialEntityInfo']>, ParentType, ContextType>;
  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
  year?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type YearlyLedgerReportFinancialEntityInfoResolvers<ContextType = GraphQLModules.Context, ParentType extends ResolversParentTypes['YearlyLedgerReportFinancialEntityInfo'] = ResolversParentTypes['YearlyLedgerReportFinancialEntityInfo']> = {
  closingBalance?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  entity?: Resolver<ResolversTypes['FinancialEntity'], ParentType, ContextType>;
  openingBalance?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  records?: Resolver<ReadonlyArray<ResolversTypes['SingleSidedLedgerRecord']>, ParentType, ContextType>;
  totalCredit?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  totalDebit?: Resolver<ResolversTypes['FinancialAmount'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type Resolvers<ContextType = GraphQLModules.Context> = {
  BankDepositCharge?: BankDepositChargeResolvers<ContextType>;
  BankFinancialAccount?: BankFinancialAccountResolvers<ContextType>;
  Business?: BusinessResolvers<ContextType>;
  BusinessTransaction?: BusinessTransactionResolvers<ContextType>;
  BusinessTransactionSum?: BusinessTransactionSumResolvers<ContextType>;
  BusinessTransactionsFromLedgerRecordsResult?: BusinessTransactionsFromLedgerRecordsResultResolvers<ContextType>;
  BusinessTransactionsFromLedgerRecordsSuccessfulResult?: BusinessTransactionsFromLedgerRecordsSuccessfulResultResolvers<ContextType>;
  BusinessTransactionsSumFromLedgerRecordsResult?: BusinessTransactionsSumFromLedgerRecordsResultResolvers<ContextType>;
  BusinessTransactionsSumFromLedgerRecordsSuccessfulResult?: BusinessTransactionsSumFromLedgerRecordsSuccessfulResultResolvers<ContextType>;
  BusinessTrip?: BusinessTripResolvers<ContextType>;
  BusinessTripAccommodationExpense?: BusinessTripAccommodationExpenseResolvers<ContextType>;
  BusinessTripAttendee?: BusinessTripAttendeeResolvers<ContextType>;
  BusinessTripAttendeeStay?: BusinessTripAttendeeStayResolvers<ContextType>;
  BusinessTripCarRentalExpense?: BusinessTripCarRentalExpenseResolvers<ContextType>;
  BusinessTripCharge?: BusinessTripChargeResolvers<ContextType>;
  BusinessTripExpense?: BusinessTripExpenseResolvers<ContextType>;
  BusinessTripFlightExpense?: BusinessTripFlightExpenseResolvers<ContextType>;
  BusinessTripOtherExpense?: BusinessTripOtherExpenseResolvers<ContextType>;
  BusinessTripSummary?: BusinessTripSummaryResolvers<ContextType>;
  BusinessTripSummaryRow?: BusinessTripSummaryRowResolvers<ContextType>;
  BusinessTripTravelAndSubsistenceExpense?: BusinessTripTravelAndSubsistenceExpenseResolvers<ContextType>;
  CardFinancialAccount?: CardFinancialAccountResolvers<ContextType>;
  Charge?: ChargeResolvers<ContextType>;
  ChargeMetadata?: ChargeMetadataResolvers<ContextType>;
  ChargeSortByField?: ChargeSortByFieldResolvers;
  ChargeSuggestions?: ChargeSuggestionsResolvers<ContextType>;
  ChargesWithLedgerChangesResult?: ChargesWithLedgerChangesResultResolvers<ContextType>;
  CommonCharge?: CommonChargeResolvers<ContextType>;
  CommonError?: CommonErrorResolvers<ContextType>;
  CommonTransaction?: CommonTransactionResolvers<ContextType>;
  ConversionCharge?: ConversionChargeResolvers<ContextType>;
  ConversionRate?: ConversionRateResolvers<ContextType>;
  ConversionTransaction?: ConversionTransactionResolvers<ContextType>;
  CorporateTax?: CorporateTaxResolvers<ContextType>;
  CorporateTaxRule?: CorporateTaxRuleResolvers<ContextType>;
  CorporateTaxRulePercentage?: CorporateTaxRulePercentageResolvers<ContextType>;
  CorporateTaxRulingComplianceReport?: CorporateTaxRulingComplianceReportResolvers<ContextType>;
  CorporateTaxRulingComplianceReportDifferences?: CorporateTaxRulingComplianceReportDifferencesResolvers<ContextType>;
  Country?: CountryResolvers<ContextType>;
  CreditInvoice?: CreditInvoiceResolvers<ContextType>;
  CreditcardBankCharge?: CreditcardBankChargeResolvers<ContextType>;
  CryptoWalletFinancialAccount?: CryptoWalletFinancialAccountResolvers<ContextType>;
  Currency?: CurrencyResolvers;
  DateRange?: DateRangeResolvers<ContextType>;
  DateTime?: GraphQLScalarType;
  DepreciationCategory?: DepreciationCategoryResolvers<ContextType>;
  DepreciationRecord?: DepreciationRecordResolvers<ContextType>;
  DividendCharge?: DividendChargeResolvers<ContextType>;
  DividendMock?: GraphQLScalarType;
  Document?: DocumentResolvers<ContextType>;
  DocumentSuggestions?: DocumentSuggestionsResolvers<ContextType>;
  DocumentType?: DocumentTypeResolvers;
  DynamicReportInfo?: DynamicReportInfoResolvers<ContextType>;
  DynamicReportNode?: DynamicReportNodeResolvers<ContextType>;
  DynamicReportNodeData?: DynamicReportNodeDataResolvers<ContextType>;
  Employee?: EmployeeResolvers<ContextType>;
  Error?: ErrorResolvers<ContextType>;
  ExchangeRates?: ExchangeRatesResolvers<ContextType>;
  FileScalar?: GraphQLScalarType;
  FinancialAccount?: FinancialAccountResolvers<ContextType>;
  FinancialAmount?: FinancialAmountResolvers<ContextType>;
  FinancialCharge?: FinancialChargeResolvers<ContextType>;
  FinancialDocument?: FinancialDocumentResolvers<ContextType>;
  FinancialEntity?: FinancialEntityResolvers<ContextType>;
  FinancialIntAmount?: FinancialIntAmountResolvers<ContextType>;
  FlagForeignFeeTransactionsResult?: FlagForeignFeeTransactionsResultResolvers<ContextType>;
  ForeignCurrencySum?: ForeignCurrencySumResolvers<ContextType>;
  Fund?: FundResolvers<ContextType>;
  GenerateMonthlyClientDocumentsResult?: GenerateMonthlyClientDocumentsResultResolvers<ContextType>;
  GeneratedLedgerRecords?: GeneratedLedgerRecordsResolvers<ContextType>;
  IncomeExpenseChart?: IncomeExpenseChartResolvers<ContextType>;
  IncomeExpenseChartMonthData?: IncomeExpenseChartMonthDataResolvers<ContextType>;
  InsertDepreciationCategoryResult?: InsertDepreciationCategoryResultResolvers<ContextType>;
  InsertDepreciationRecordResult?: InsertDepreciationRecordResultResolvers<ContextType>;
  InsertDocumentResult?: InsertDocumentResultResolvers<ContextType>;
  InsertDocumentSuccessfulResult?: InsertDocumentSuccessfulResultResolvers<ContextType>;
  InsertSalaryRecordsResult?: InsertSalaryRecordsResultResolvers<ContextType>;
  InsertSalaryRecordsSuccessfulResult?: InsertSalaryRecordsSuccessfulResultResolvers<ContextType>;
  InternalTransferCharge?: InternalTransferChargeResolvers<ContextType>;
  Invoice?: InvoiceResolvers<ContextType>;
  InvoiceReceipt?: InvoiceReceiptResolvers<ContextType>;
  Ledger?: LedgerResolvers<ContextType>;
  LedgerBalanceInfo?: LedgerBalanceInfoResolvers<ContextType>;
  LedgerBalanceUnbalancedEntity?: LedgerBalanceUnbalancedEntityResolvers<ContextType>;
  LedgerRecord?: LedgerRecordResolvers<ContextType>;
  LedgerValidation?: LedgerValidationResolvers<ContextType>;
  Linkable?: LinkableResolvers<ContextType>;
  LtdFinancialEntity?: LtdFinancialEntityResolvers<ContextType>;
  MergeChargeResult?: MergeChargeResultResolvers<ContextType>;
  MergeChargeSuccessfulResult?: MergeChargeSuccessfulResultResolvers<ContextType>;
  MergeChargesByTransactionReferenceResult?: MergeChargesByTransactionReferenceResultResolvers<ContextType>;
  MiscExpense?: MiscExpenseResolvers<ContextType>;
  MissingChargeInfo?: MissingChargeInfoResolvers;
  MonthlyVatCharge?: MonthlyVatChargeResolvers<ContextType>;
  Mutation?: MutationResolvers<ContextType>;
  OtherDocument?: OtherDocumentResolvers<ContextType>;
  PCNFileResult?: PcnFileResultResolvers<ContextType>;
  PageInfo?: PageInfoResolvers<ContextType>;
  PaginatedBusinesses?: PaginatedBusinessesResolvers<ContextType>;
  PaginatedCharges?: PaginatedChargesResolvers<ContextType>;
  PaginatedFinancialEntities?: PaginatedFinancialEntitiesResolvers<ContextType>;
  PensionFund?: PensionFundResolvers<ContextType>;
  PersonalFinancialEntity?: PersonalFinancialEntityResolvers<ContextType>;
  ProfitAndLossReport?: ProfitAndLossReportResolvers<ContextType>;
  ProfitAndLossReportYear?: ProfitAndLossReportYearResolvers<ContextType>;
  Proforma?: ProformaResolvers<ContextType>;
  Query?: QueryResolvers<ContextType>;
  Rate?: GraphQLScalarType;
  Receipt?: ReceiptResolvers<ContextType>;
  ReportCommentary?: ReportCommentaryResolvers<ContextType>;
  ReportCommentaryRecord?: ReportCommentaryRecordResolvers<ContextType>;
  ReportCommentarySubRecord?: ReportCommentarySubRecordResolvers<ContextType>;
  Salary?: SalaryResolvers<ContextType>;
  SalaryCharge?: SalaryChargeResolvers<ContextType>;
  SicknessDays?: SicknessDaysResolvers<ContextType>;
  SingleSidedLedgerRecord?: SingleSidedLedgerRecordResolvers<ContextType>;
  SortCode?: SortCodeResolvers<ContextType>;
  Suggestions?: SuggestionsResolvers<ContextType>;
  Tag?: TagResolvers<ContextType>;
  TaxCategory?: TaxCategoryResolvers<ContextType>;
  TaxReport?: TaxReportResolvers<ContextType>;
  TaxReportYear?: TaxReportYearResolvers<ContextType>;
  TimelessDate?: GraphQLScalarType;
  TrainingFund?: TrainingFundResolvers<ContextType>;
  Transaction?: TransactionResolvers<ContextType>;
  TransactionDirection?: TransactionDirectionResolvers;
  TransactionSuggestions?: TransactionSuggestionsResolvers<ContextType>;
  URL?: GraphQLScalarType;
  UUID?: GraphQLScalarType;
  UncategorizedTransaction?: UncategorizedTransactionResolvers<ContextType>;
  Unprocessed?: UnprocessedResolvers<ContextType>;
  UpdateBusinessResponse?: UpdateBusinessResponseResolvers<ContextType>;
  UpdateChargeResult?: UpdateChargeResultResolvers<ContextType>;
  UpdateChargeSuccessfulResult?: UpdateChargeSuccessfulResultResolvers<ContextType>;
  UpdateDepreciationCategoryResult?: UpdateDepreciationCategoryResultResolvers<ContextType>;
  UpdateDepreciationRecordResult?: UpdateDepreciationRecordResultResolvers<ContextType>;
  UpdateDocumentResult?: UpdateDocumentResultResolvers<ContextType>;
  UpdateDocumentSuccessfulResult?: UpdateDocumentSuccessfulResultResolvers<ContextType>;
  UpdateSalaryRecordResult?: UpdateSalaryRecordResultResolvers<ContextType>;
  UpdateSalaryRecordSuccessfulResult?: UpdateSalaryRecordSuccessfulResultResolvers<ContextType>;
  UpdateTaxCategoryResponse?: UpdateTaxCategoryResponseResolvers<ContextType>;
  UpdateTransactionResult?: UpdateTransactionResultResolvers<ContextType>;
  UploadDocumentResult?: UploadDocumentResultResolvers<ContextType>;
  UploadDocumentSuccessfulResult?: UploadDocumentSuccessfulResultResolvers<ContextType>;
  VacationDays?: VacationDaysResolvers<ContextType>;
  ValidationData?: ValidationDataResolvers<ContextType>;
  VatMock?: GraphQLScalarType;
  VatReportRecord?: VatReportRecordResolvers<ContextType>;
  VatReportResult?: VatReportResultResolvers<ContextType>;
  YearOfRelevance?: YearOfRelevanceResolvers<ContextType>;
  YearlyLedgerReport?: YearlyLedgerReportResolvers<ContextType>;
  YearlyLedgerReportFinancialEntityInfo?: YearlyLedgerReportFinancialEntityInfoResolvers<ContextType>;
};

export type DirectiveResolvers<ContextType = GraphQLModules.Context> = {
  auth?: AuthDirectiveResolver<any, any, ContextType>;
  defer?: DeferDirectiveResolver<any, any, ContextType>;
  stream?: StreamDirectiveResolver<any, any, ContextType>;
};

export type DateTime = Scalars["DateTime"];
export type DividendMock = Scalars["DividendMock"];
export type FileScalar = Scalars["FileScalar"];
export type Rate = Scalars["Rate"];
export type TimelessDate = Scalars["TimelessDate"];
export type Url = Scalars["URL"];
export type Uuid = Scalars["UUID"];
export type VatMock = Scalars["VatMock"];